mayu-live 0.0.0

data/lib/mayu/state/action_creator.rb

@@ -0,0 +1,191 @@
+# typed: strict
+
+require "nanoid"
+require_relative "../fetch"
+
+module Mayu
+  module State
+    module ActionCreator
+      extend T::Sig
+
+      class Base
+        extend T::Sig
+
+        sig { returns(Symbol) }
+        attr_reader :type
+
+        sig { params(type: Symbol).void }
+        def initialize(type)
+          @type = type
+        end
+
+        sig do
+          params(payload: T.untyped).returns(
+            T.any(Store::ActionHash, Store::Thunk)
+          )
+        end
+        def call(payload = nil)
+          { type:, payload: }
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ===(other)
+          case other
+          when Hash
+            @type == other[:type]
+          when ActionWrapper
+            @type == other.type
+          else
+            super
+          end
+        end
+      end
+
+      class StaticActionCreator < Base
+      end
+
+      class PreparedActionCreator < Base
+        ProcType = T.type_alias { T.proc.returns(Store::ActionHash) }
+
+        sig do
+          params(type: Symbol, block: T.proc.returns(Store::ActionHash)).void
+        end
+        def initialize(type, &block)
+          super(type)
+          @prepare = block
+        end
+
+        sig do
+          params(args: T.untyped, kwargs: T.untyped).returns(Store::ActionHash)
+        end
+        def call(*args, **kwargs)
+          { type: }.merge(T.unsafe(@prepare).call(*args, **kwargs))
+        end
+      end
+
+      class AsyncActionCreator < Base
+        ProcType =
+          T.type_alias do
+            T.proc.params(arg0: Store, args: T.untyped, kwargs: T.untyped).void
+          end
+
+        sig { returns(StaticActionCreator) }
+        attr_reader :pending
+        sig { returns(StaticActionCreator) }
+        attr_reader :fulfilled
+        sig { returns(StaticActionCreator) }
+        attr_reader :rejected
+
+        sig { params(type: Symbol, block: ProcType).void }
+        def initialize(type, &block)
+          super(type)
+          @block = block
+          @pending =
+            T.let(
+              StaticActionCreator.new(:"#{type}/pending"),
+              StaticActionCreator
+            )
+          @fulfilled =
+            T.let(
+              StaticActionCreator.new(:"#{type}/fulfilled"),
+              StaticActionCreator
+            )
+          @rejected =
+            T.let(
+              StaticActionCreator.new(:"#{type}/rejected"),
+              StaticActionCreator
+            )
+        end
+
+        sig do
+          override
+            .params(args: T.untyped, parent: Async::Task, kwargs: T.untyped)
+            .returns(Store::Thunk)
+        end
+        def call(*args, parent: Async::Task.current, **kwargs)
+          ->(store) do
+            parent.async do |task|
+              request_id = Nanoid.generate()
+              store.dispatch(pending, *args, **kwargs.merge(request_id:))
+              result =
+                T.unsafe(@block).call(
+                  store,
+                  *args,
+                  **kwargs.merge(task:, request_id:)
+                )
+              store.dispatch(fulfilled, result)
+            rescue => error
+              store.dispatch(rejected, { error:, request_id: })
+            end
+          end
+        end
+      end
+
+      module ActionContext
+        extend T::Sig
+
+        FetchResponse = T.type_alias { String }
+        Header = T.type_alias { [String, String] }
+
+        sig do
+          params(
+            resource: T.any(String, URI),
+            method: Symbol,
+            headers: T::Array[Header],
+            body: T.nilable(String),
+            redirect: Symbol,
+            referrer: String,
+            keepalive: T::Boolean
+          ).returns(FetchResponse)
+        end
+        def fetch(
+          resource,
+          method: :GET,
+          headers: [],
+          body: nil,
+          redirect: :follow,
+          referrer: "mayu-live-fetch/#{Mayu::VERSION}",
+          keepalive: false
+        )
+          internet = Async::HTTP::Internet.new
+
+          case method
+          when :GET
+            internet.get(resource, headers)
+          when :POST
+            internet.post(resource, headers, body)
+          when :PUT
+            internet.put(resource, headers, body)
+          when :PATCH
+            internet.patch(resource, headers, body)
+          end
+        ensure
+          internet&.close
+        end
+      end
+
+      sig do
+        params(
+          type: Symbol,
+          block: T.nilable(PreparedActionCreator::ProcType)
+        ).returns(Base)
+      end
+      def self.create(type, &block)
+        if block_given?
+          PreparedActionCreator.new(type, &block)
+        else
+          StaticActionCreator.new(type)
+        end
+      end
+
+      sig do
+        params(type: Symbol, block: AsyncActionCreator::ProcType).returns(
+          AsyncActionCreator
+        )
+      end
+      def self.async(type, &block)
+        AsyncActionCreator.new(type, &block)
+      end
+    end
+  end
+end

data/lib/mayu/state/action_wrapper.rb

@@ -0,0 +1,30 @@
+# typed: strict
+
+module Mayu
+  module State
+    class ActionWrapper
+      extend T::Sig
+
+      sig { returns(Symbol) }
+      attr_reader :type
+      sig { returns(T.untyped) }
+      attr_reader :payload
+
+      sig { params(type: Symbol, payload: T.untyped).void }
+      def initialize(type:, payload:)
+        @type = type
+        @payload = payload
+      end
+
+      sig { params(key: T.untyped).returns(T.untyped) }
+      def [](key) = @payload[key]
+      sig { params(key: T.untyped, block: T.untyped).returns(T.untyped) }
+      def fetch(key, &block) = @payload.fetch(key, &block)
+
+      sig { returns(String) }
+      def inspect
+        "#<Action/#{type} payload=#{payload.inspect}>"
+      end
+    end
+  end
+end

data/lib/mayu/state/loader.rb

@@ -0,0 +1,220 @@
+# typed: true
+
+require_relative "store"
+
+module Mayu
+  module State
+    class Selector
+      module SelectorModule
+        extend T::Sig
+
+        sig do
+          params(
+            block: T.proc.params(state: T.untyped).returns(T.untyped)
+          ).returns(Selector)
+        end
+        def selector(&block)
+          Selector.new
+        end
+
+        sig do
+          params(
+            block: T.proc.params(state: T.untyped).returns(T.untyped)
+          ).returns(Module)
+        end
+        def self.build(&block)
+          mod = Module.new
+          mod.send(:extend, SelectorModule)
+          mod.class_eval(&block)
+          mod
+        end
+      end
+
+      extend T::Sig
+    end
+
+    module Actions
+      module ActionModule
+        extend T::Sig
+
+        sig do
+          params(
+            type: Symbol,
+            block: T.nilable(ActionCreator::PreparedActionCreator::ProcType)
+          ).returns(ActionCreator::Base)
+        end
+        def action(type, &block)
+          ActionCreator.create(type, &block)
+        end
+
+        sig do
+          params(
+            type: Symbol,
+            block: ActionCreator::AsyncActionCreator::ProcType
+          ).returns(ActionCreator::AsyncActionCreator)
+        end
+        def async(type, &block)
+          ActionCreator.async(type, &block)
+        end
+
+        sig do
+          params(
+            block: T.proc.params(state: T.untyped).returns(T.untyped)
+          ).returns(Module)
+        end
+        def self.build(&block)
+          mod = Module.new
+          mod.send(:extend, ActionModule)
+          mod.class_eval(&block)
+          mod
+        end
+      end
+
+      extend T::Sig
+    end
+
+    module ReducerDSL
+      extend T::Sig
+      extend T::Helpers
+      interface!
+
+      sig { abstract.params(kwargs: T.untyped).void }
+      def initial_state(**kwargs)
+      end
+
+      sig do
+        abstract
+          .params(action: ActionCreator::Base, reducer: Store::Reducer)
+          .void
+      end
+      def reducer(action, &reducer)
+      end
+
+      sig { abstract.params(url: String, options: T.untyped).void }
+      def fetch(url, **options)
+      end
+
+      sig do
+        abstract
+          .params(
+            block:
+              T.proc.bind(Selector::SelectorModule).params(arg0: T.untyped).void
+          )
+          .returns(Module)
+      end
+      def selectors(&block)
+      end
+
+      sig do
+        abstract
+          .params(
+            block:
+              T.proc.bind(Actions::ActionModule).params(arg0: T.untyped).void
+          )
+          .returns(Module)
+      end
+      def actions(&block)
+      end
+    end
+
+    class Loader
+      extend T::Sig
+
+      class ReducerBuilder
+        extend ::T::Sig
+        include ::Mayu::State::ReducerDSL
+
+        sig do
+          params(source: ::String, path: ::String).returns(
+            T::Hash[Symbol, T.untyped]
+          )
+        end
+        def self.build(source, path)
+          { initial_state: nil, reducers: [], actions: [] }.tap do
+            new(File.basename(path, ".*"), _1).instance_eval(source, path, 0)
+          end
+        end
+
+        sig { params(prefix: String, data: T::Hash[::Symbol, T.untyped]).void }
+        def initialize(prefix, data)
+          @prefix = prefix
+          @data = data
+        end
+
+        sig { override.params(kwargs: T.untyped).void }
+        def initial_state(**kwargs)
+          @data[:initial_state] = kwargs
+        end
+
+        sig { override.params(url: String, options: T.untyped).void }
+        def fetch(url, **options)
+        end
+
+        sig do
+          override
+            .params(
+              block:
+                T
+                  .proc
+                  .bind(Selector::SelectorModule)
+                  .params(arg0: T.untyped)
+                  .void
+            )
+            .returns(Module)
+        end
+        def selectors(&block)
+          @data[:selectors] = Selector::SelectorModule.build(&block)
+        end
+
+        sig do
+          override
+            .params(
+              block:
+                T.proc.bind(Actions::ActionModule).params(arg0: T.untyped).void
+            )
+            .returns(Module)
+        end
+        def actions(&block)
+          @data[:actions] = Actions::ActionModule.build(&block)
+        end
+
+        sig do
+          override
+            .params(action: ActionCreator::Base, reducer: Store::Reducer)
+            .void
+        end
+        def reducer(action, &reducer)
+          @data[:reducers].push([action, reducer])
+        end
+      end
+
+      sig { params(directory: String).void }
+      def initialize(directory)
+        @directory = directory
+      end
+
+      sig { returns(Store::Reducers) }
+      def load
+        Dir[File.join(@directory, "*.rb")]
+          .map do |path|
+            data = ReducerBuilder.build(File.read(path), path)
+            name = File.basename(path, ".*").capitalize.to_sym
+
+            [
+              name,
+              ->(state, action) do
+                state ||= data[:initial_state]
+
+                data[:reducers]
+                  .filter { _1 === action }
+                  .reduce(
+                    state || data[:initial_state]
+                  ) { |state, (_, reducer)| reducer.call(state, action) }
+              end
+            ]
+          end
+          .to_h
+      end
+    end
+  end
+end

data/lib/mayu/state/store.rb

@@ -0,0 +1,82 @@
+# typed: strict
+
+require "async"
+require "async/semaphore"
+require_relative "action_wrapper"
+require_relative "action_creator"
+
+module Mayu
+  module State
+    class Store
+      extend T::Sig
+
+      sig { returns(T.untyped) }
+      def marshal_dump
+        [@state]
+      end
+
+      sig { params(a: T.untyped).void }
+      def marshal_load(a)
+        @state = a.first
+      end
+
+      State = T.type_alias { T.untyped }
+      Reducer =
+        T.type_alias do
+          T.proc.params(arg0: State, arg1: ActionWrapper).returns(State)
+        end
+      Thunk = T.type_alias { T.proc.params(arg0: Store).void }
+      Reducers = T.type_alias { T::Hash[Symbol, Store::Reducer] }
+
+      sig { returns(State) }
+      attr_reader :state
+
+      sig { params(initial_state: State, reducers: Reducers).void }
+      def initialize(initial_state, reducers:)
+        @state = T.let(initial_state, State)
+        @reducer = T.let(combine_reducers(reducers), Reducer)
+        @semaphore = T.let(Async::Semaphore.new, Async::Semaphore)
+
+        dispatch({ type: :__INIT__, payload: nil })
+      end
+
+      ActionHash = T.type_alias { T::Hash[Symbol, T.untyped] }
+
+      sig do
+        params(
+          action: T.any(ActionHash, ActionCreator::Base, Thunk),
+          args: T.untyped,
+          kwargs: T.untyped
+        ).void
+      end
+      def dispatch(action, *args, **kwargs)
+        if action.is_a?(ActionCreator::Base)
+          return dispatch(T.unsafe(action).call(*args, **kwargs))
+        end
+
+        return action.call(self) if action.is_a?(Proc)
+
+        @semaphore.async do
+          new_state =
+            @reducer.call(@state.dup, T.unsafe(ActionWrapper).new(**action))
+          @state = new_state
+        rescue => e
+          Console.logger.error(self) { "Reducer crashed" }
+        end
+
+        nil
+      end
+
+      private
+
+      sig { params(reducers: T::Hash[Symbol, Reducer]).returns(Reducer) }
+      def combine_reducers(reducers)
+        ->(state, action) do
+          reducers.reduce(state) do |new_state, (name, reducer)|
+            new_state.merge(name => reducer.call(state[name], action))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mayu/state.rb

@@ -0,0 +1,8 @@
+# typed: strict
+
+require_relative "state/store"
+
+module Mayu
+  module State
+  end
+end

data/lib/mayu/state.test.rb

@@ -0,0 +1,97 @@
+# typed: true
+
+require "minitest/autorun"
+require "test_helper"
+
+require_relative "vdom/descriptor"
+require_relative "state"
+
+class TestState < Minitest::Test
+  class MyComponent < Mayu::Component::Base
+    def render
+    end
+  end
+
+  State = Mayu::State
+
+  INCREMENT = State::ActionCreator.create(:increment)
+  DECREMENT = State::ActionCreator.create(:decrement)
+  ADD_ITEM = State::ActionCreator.create(:add_item)
+  REMOVE_ITEM = State::ActionCreator.create(:remove_item)
+  THUNK =
+    State::ActionCreator.async(:hello) do |store|
+      store.dispatch(INCREMENT)
+      sleep 1
+      store.dispatch(INCREMENT)
+      sleep 1
+      store.dispatch(DECREMENT)
+    end
+
+  def test_initialize_descriptor
+    Sync do
+      count_reducer = ->(state, action) do
+        state ||= { count: 0 }
+
+        case action
+        when INCREMENT
+          state.merge(count: state[:count].succ)
+        when DECREMENT
+          state.merge(count: state[:count].pred)
+        else
+          state
+        end
+      end
+
+      totals_reducer = ->(state, action) do
+        state ||= 0
+
+        case action
+        in ADD_ITEM
+          state += 1
+        in REMOVE_ITEM
+          state -= 1
+        else
+          state
+        end
+      end
+
+      items_reducer = ->(state, action) do
+        state ||= []
+        p action
+
+        case action
+        in ADD_ITEM
+          state + [action[:item]]
+        in REMOVE_ITEM
+          state - [action[:item]]
+        else
+          state
+        end
+      end
+
+      @store =
+        State::Store.new(
+          { total: 0, items: [] },
+          reducers: {
+            count1: count_reducer,
+            count2: count_reducer,
+            items: items_reducer,
+            totals: totals_reducer
+          }
+        )
+
+      @store.dispatch(ADD_ITEM, item: "Apple")
+      @store.dispatch(ADD_ITEM, item: "Banana")
+      @store.dispatch(REMOVE_ITEM, item: "Apple")
+      @store.dispatch(ADD_ITEM, item: "Papaya")
+      @store.dispatch(INCREMENT)
+
+      puts @store.state
+      @store.dispatch(THUNK)
+      sleep 0.1
+      @store.dispatch(THUNK)
+      puts "hello"
+      puts @store.state
+    end
+  end
+end