sandals 0.1.0

data/lib/sandals/server.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "webrick"
+require "json"
+require "securerandom"
+
+module Sandals
+  class Server
+    SESSION_COOKIE = "sandals_session"
+    MAX_UPLOAD_SIZE = 10 * 1024 * 1024
+
+    attr_reader :port
+
+    def initialize(application, port: 0, reload_path: nil)
+      @application_factory = application
+      @reloader = CodeReloader.new(reload_path) if reload_path
+      @applications = {}
+      @applications_mutex = Mutex.new
+      @server = WEBrick::HTTPServer.new(
+        BindAddress: "127.0.0.1",
+        Port: port,
+        AccessLog: [],
+        Logger: WEBrick::Log.new(File::NULL)
+      )
+      @port = @server.listeners.first.addr[1]
+      @server.mount_proc("/") { |request, response| render(request, response) }
+    end
+
+    def start
+      @server.start
+    end
+
+    def stop
+      @server.shutdown
+    end
+
+    def url
+      "http://127.0.0.1:#{port}"
+    end
+
+    private
+
+    def render(request, response)
+      if request.request_method == "GET" && request.path == HTMLRenderer::TURBO_URL
+        render_turbo(response)
+        return
+      end
+
+      if request.request_method == "GET" && request.path == "/__sandals/reload"
+        render_reload(response)
+        return
+      end
+
+      application = application_for(request, response)
+      if request.request_method == "POST" && request.path == "/events"
+        render_event(request, response, application)
+      elsif request.request_method == "POST" && request.path == "/files"
+        render_file(request, response, application)
+      else
+        response.status = 200
+        response["content-type"] = "text/html; charset=utf-8"
+        response.body = application.render(development_reload: !@reloader.nil?)
+      end
+    rescue StandardError => error
+      response.status = 500
+      response["content-type"] = "text/plain; charset=utf-8"
+      response.body = "#{error.class}: #{error.message}\n#{error.backtrace&.first}"
+    end
+
+    def render_turbo(response)
+      response.status = 200
+      response["cache-control"] = "public, max-age=31536000, immutable"
+      response["content-type"] = "text/javascript; charset=utf-8"
+      response.body = File.binread(HTMLRenderer::TURBO_PATH)
+    end
+
+    def render_event(request, response, application)
+      message = JSON.parse(request.body)
+      revision, content = application.dispatch(
+        revision: message.fetch("revision"),
+        oldest_pending_revision: message.fetch("oldest_pending_revision"),
+        events: message.fetch("events")
+      )
+
+      render_update(response, revision, content)
+    rescue ActionError => error
+      render_action_error(response, message.fetch("revision"), error)
+    end
+
+    def render_file(request, response, application)
+      form = request.query
+      revision = Integer(form.fetch("revision"))
+      file_data = form.fetch("file")
+      content = file_data.to_s.b
+      if content.bytesize > MAX_UPLOAD_SIZE
+        response.status = 413
+        response["content-type"] = "text/plain; charset=utf-8"
+        response.body = "uploaded file exceeds the 10 MB limit"
+        return
+      end
+
+      file = UploadedFile.new(
+        name: file_data.filename,
+        content_type: file_data["content-type"] || "application/octet-stream",
+        content:
+      )
+      next_revision, rendered_view = application.dispatch(
+        revision:,
+        oldest_pending_revision: Integer(form.fetch("oldest_pending_revision")),
+        events: [
+          {
+            "target" => form.fetch("target"),
+            "event" => "change",
+            "value" => file
+          }
+        ]
+      )
+
+      render_update(response, next_revision, rendered_view)
+    rescue ActionError => error
+      render_action_error(response, revision, error)
+    end
+
+    def render_update(response, revision, content)
+      response.status = 200
+      response["content-type"] = "text/vnd.turbo-stream.html; charset=utf-8"
+      response["X-Sandals-Revision"] = revision.to_s
+      response.body = HTMLRenderer.new.clear_action_error + <<~HTML
+        <turbo-stream action="update" method="morph" target="sandals-view">
+          <template>#{content}</template>
+        </turbo-stream>
+      HTML
+    end
+
+    def render_action_error(response, revision, error)
+      response.status = 500
+      response["content-type"] = "text/vnd.turbo-stream.html; charset=utf-8"
+      response["X-Sandals-Revision"] = revision.to_s
+      response.body = HTMLRenderer.new.render_action_error(error)
+    end
+
+    def render_reload(response)
+      unless @reloader
+        response.status = 404
+        response.body = "development reload is not enabled"
+        return
+      end
+
+      result = @reloader.check
+      if result.application
+        @applications_mutex.synchronize do
+          @application_factory = result.application
+          @applications.clear
+        end
+      end
+
+      response.status = 200
+      response["cache-control"] = "no-store"
+      response["content-type"] = "application/json; charset=utf-8"
+      response.body = JSON.generate(
+        version: result.version,
+        error: result.error
+      )
+    end
+
+    def application_for(request, response)
+      session_id = request.cookies.find { |cookie| cookie.name == SESSION_COOKIE }&.value
+      application = @applications_mutex.synchronize { @applications[session_id] }
+      return application if application
+
+      session_id = SecureRandom.hex(16)
+      application = @application_factory.new_session
+      @applications_mutex.synchronize { @applications[session_id] = application }
+      response["Set-Cookie"] =
+        "#{SESSION_COOKIE}=#{session_id}; Path=/; HttpOnly; SameSite=Lax"
+      application
+    end
+  end
+end

data/lib/sandals/snapshot_history.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sandals
+  class SnapshotHistory
+    Snapshot = Data.define(:revision, :view, :controls)
+
+    def initialize
+      @revision = 0
+      @snapshots = []
+    end
+
+    def publish(view, controls:)
+      @revision += 1
+      snapshot = Snapshot.new(@revision, view, controls)
+      @snapshots << snapshot
+      snapshot
+    end
+
+    def fetch(revision)
+      snapshot = @snapshots.find { |candidate| candidate.revision == revision }
+      return snapshot if snapshot
+
+      raise ArgumentError, "unknown revision: #{revision}"
+    end
+
+    def current
+      @snapshots.last
+    end
+
+    def discard_before(revision)
+      @snapshots.reject! { |snapshot| snapshot.revision < revision }
+    end
+  end
+end

data/lib/sandals/test_session.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+module Sandals
+  class TestSession
+    class AssertionError < StandardError; end
+
+    class FieldLocator
+      attr_reader :label
+
+      def initialize(session, label)
+        @session = session
+        @label = label.to_s
+      end
+
+      def fill(value)
+        @session.fill(label, with: value)
+      end
+
+      def check
+        @session.check(label)
+      end
+
+      def uncheck
+        @session.uncheck(label)
+      end
+
+      def select(option)
+        @session.select(option, from: label)
+      end
+
+      def choose(option)
+        @session.choose(option, from: label)
+      end
+
+      def value
+        @session.field_value(label)
+      end
+
+      def attach(file)
+        @session.attach(label, file:)
+      end
+
+      def inspect
+        %(#<#{self.class} label="#{label}">)
+      end
+    end
+
+    FIELD_TYPES = [
+      TextField,
+      NumberField,
+      TextArea,
+      Checkbox,
+      Select,
+      Radio,
+      FileField
+    ].freeze
+    FILLABLE_TYPES = [TextField, NumberField, TextArea].freeze
+
+    def initialize(application)
+      @application = application
+      use_snapshot(@application.__send__(:publish_view))
+    end
+
+    def field(label)
+      find_field(label)
+      FieldLocator.new(self, label)
+    end
+
+    def fill(label, with:)
+      control = find_field(label)
+      unless FILLABLE_TYPES.any? { |type| control.is_a?(type) }
+        raise AssertionError, %(field "#{label}" cannot be filled)
+      end
+
+      dispatch(control, "change", "value" => serialize(with))
+      self
+    end
+
+    def field_value(label_or_locator)
+      label =
+        if label_or_locator.is_a?(FieldLocator)
+          label_or_locator.label
+        else
+          label_or_locator
+        end
+      control = find_field(label)
+      return control.checked? if control.is_a?(Checkbox)
+
+      control.value
+    end
+
+    def click(content)
+      button = find_one(
+        controls.select do |control|
+          control.is_a?(Button) && control.content == content.to_s
+        end,
+        %(button named "#{content}")
+      )
+      dispatch(button, button.is_a?(Submit) ? "submit" : "click")
+      self
+    end
+
+    def attach(label, file:)
+      control = find_field(label)
+      unless control.is_a?(FileField)
+        raise AssertionError, %(field "#{label}" is not a file field)
+      end
+
+      uploaded_file =
+        if file.is_a?(UploadedFile)
+          file
+        else
+          path = File.expand_path(file.to_s)
+          UploadedFile.new(
+            name: File.basename(path),
+            content_type: content_type_for(path),
+            content: File.binread(path)
+          )
+        end
+
+      dispatch(control, "change", "value" => uploaded_file)
+      self
+    end
+
+    def check(label)
+      change_checkbox(label, true)
+    end
+
+    def uncheck(label)
+      change_checkbox(label, false)
+    end
+
+    def select(option, from:)
+      control = find_field(from)
+      unless control.instance_of?(Select)
+        raise AssertionError, %(field "#{from}" is not a select)
+      end
+
+      change_option(control, option)
+    end
+
+    def choose(option, from:)
+      control = find_field(from)
+      unless control.is_a?(Radio)
+        raise AssertionError, %(field "#{from}" is not a radio)
+      end
+
+      change_option(control, option)
+    end
+
+    def assert_text(expected)
+      return self if text?(expected)
+
+      raise AssertionError,
+        %(expected the view to include "#{expected}", but it rendered:\n#{visible_text})
+    end
+
+    def refute_text(unexpected)
+      return self unless text?(unexpected)
+
+      raise AssertionError,
+        %(expected the view not to include "#{unexpected}", but it rendered:\n#{visible_text})
+    end
+
+    def text?(expected)
+      visible_text.include?(expected.to_s)
+    end
+
+    def notice?(expected)
+      messages(Notice).include?(expected.to_s)
+    end
+
+    def error?(expected)
+      messages(Error).include?(expected.to_s)
+    end
+
+    def assert_notice(expected)
+      assert_message(Notice, "notice", expected)
+    end
+
+    def refute_notice(unexpected)
+      refute_message(Notice, "notice", unexpected)
+    end
+
+    def assert_error(expected)
+      assert_message(Error, "error", expected)
+    end
+
+    def refute_error(unexpected)
+      refute_message(Error, "error", unexpected)
+    end
+
+    def field_error(label_or_locator)
+      label =
+        if label_or_locator.is_a?(FieldLocator)
+          label_or_locator.label
+        else
+          label_or_locator
+        end
+      find_field(label).error
+    end
+
+    def assert_field_error(label_or_locator, expected)
+      actual = field_error(label_or_locator)
+      return self if actual == expected.to_s
+
+      label =
+        if label_or_locator.is_a?(FieldLocator)
+          label_or_locator.label
+        else
+          label_or_locator
+        end
+
+      raise AssertionError,
+        "expected field \"#{label}\" to have error \"#{expected}\", " \
+        "but its error was #{actual.inspect}"
+    end
+
+    private
+
+    def find_field(label)
+      find_one(
+        controls.select do |control|
+          FIELD_TYPES.any? { |type| control.is_a?(type) } &&
+            control.label == label.to_s
+        end,
+        %(field labeled "#{label}")
+      )
+    end
+
+    def find_one(matches, description)
+      return matches.first if matches.one?
+
+      raise AssertionError,
+        "expected one #{description}, but found #{matches.length}"
+    end
+
+    def assert_message(type, name, expected)
+      return self if messages(type).include?(expected.to_s)
+
+      raise AssertionError,
+        %(expected #{name} "#{expected}", but found #{messages(type).inspect})
+    end
+
+    def refute_message(type, name, unexpected)
+      return self unless messages(type).include?(unexpected.to_s)
+
+      raise AssertionError,
+        %(expected not to find #{name} "#{unexpected}", but found #{messages(type).inspect})
+    end
+
+    def messages(type)
+      descendants(@view)
+        .select { |element| element.is_a?(type) }
+        .map(&:content)
+    end
+
+    def controls
+      descendants(@view).select do |element|
+        FIELD_TYPES.any? { |type| element.is_a?(type) } ||
+          element.is_a?(Button)
+      end
+    end
+
+    def descendants(container)
+      container.children.flat_map do |element|
+        element.is_a?(Container) ? [element, *descendants(element)] : element
+      end
+    end
+
+    def dispatch(control, event, attributes = {})
+      revision, = @application.dispatch(
+        revision: @revision,
+        events: [
+          {
+            "target" => control.id,
+            "event" => event,
+            **attributes
+          }
+        ]
+      )
+      snapshot = @application.__send__(:current_snapshot)
+      raise "snapshot revision mismatch" unless snapshot.revision == revision
+
+      use_snapshot(snapshot)
+    end
+
+    def change_checkbox(label, checked)
+      control = find_field(label)
+      unless control.is_a?(Checkbox)
+        raise AssertionError, %(field "#{label}" is not a checkbox)
+      end
+
+      dispatch(control, "change", "value" => checked)
+      self
+    end
+
+    def change_option(control, option_label)
+      option = find_one(
+        control.options.select { |candidate| candidate.label == option_label.to_s },
+        %(option named "#{option_label}" in field "#{control.label}")
+      )
+      dispatch(control, "change", "value" => option.value.to_s)
+      self
+    end
+
+    def use_snapshot(snapshot)
+      @revision = snapshot.revision
+      @view = snapshot.view
+    end
+
+    def serialize(value)
+      value.nil? ? "" : value.to_s
+    end
+
+    def content_type_for(path)
+      File.extname(path).downcase == ".csv" ? "text/csv" : "application/octet-stream"
+    end
+
+    def visible_text
+      text_for(@view).reject(&:empty?).join("\n")
+    end
+
+    def text_for(element)
+      case element
+      when View, Container
+        element.children.flat_map { |child| text_for(child) }
+      when Title, Subtitle, Error, Notice, Strong, Emphasis
+        [element.content]
+      when Para
+        [element.parts.flat_map { |part| text_for(part) }.join]
+      when Image
+        [element.alt]
+      when Link
+        [element.content]
+      when Table
+        [
+          *element.headers,
+          *element.rows.flat_map { |row| row.flat_map { |cell| text_for(cell) } }
+        ]
+      when TextField, NumberField, TextArea, Checkbox, Select, FileField
+        [element.label, element.error.to_s]
+      when Button
+        [element.content]
+      when String
+        [element]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/sandals/uploaded_file.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sandals
+  class UploadedFile
+    attr_reader :name, :content_type, :size
+
+    def initialize(name:, content_type:, content:)
+      @name = File.basename(name.to_s)
+      @content_type = content_type.to_s
+      @content = content.to_s.b.freeze
+      @size = @content.bytesize
+    end
+
+    def read
+      @content.dup
+    end
+  end
+end

data/lib/sandals/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sandals
+  VERSION = "0.1.0"
+end