sandals 0.1.0

data/lib/sandals/view.rb

@@ -0,0 +1,568 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Sandals
+  class View
+    UNSET = BindingResolver::UNSET
+
+    attr_reader :children
+
+    def initialize
+      @children = []
+      @containers = [self]
+      @next_control_id = 0
+    end
+
+    def title(content)
+      add Title.new(content)
+    end
+
+    def subtitle(content)
+      add Subtitle.new(content)
+    end
+
+    def para(*parts)
+      add Para.new(parts)
+    end
+
+    def error(content)
+      add Error.new(content)
+    end
+
+    def notice(content)
+      add Notice.new(content)
+    end
+
+    def image(source, alt: "")
+      add Image.new(source, alt:)
+    end
+
+    def link(content, to:)
+      add Link.new(content, to:)
+    end
+
+    def table(headers:, rows:)
+      add Table.new(headers:, rows:)
+    end
+
+    def text_field(
+      label,
+      value: UNSET,
+      error: UNSET,
+      model: UNSET,
+      bind: UNSET,
+      &action
+    )
+      value, error, action = resolve_binding(
+        model:, bind:, value:, error:, action:, default: ""
+      )
+      add TextField.new(control_id("text-field"), label, value:, error:, action:)
+    end
+
+    def number_field(
+      label,
+      value: UNSET,
+      error: UNSET,
+      model: UNSET,
+      bind: UNSET,
+      &action
+    )
+      value, error, action = resolve_binding(
+        model:, bind:, value:, error:, action:, default: nil
+      )
+      add NumberField.new(control_id("number-field"), label, value:, error:, action:)
+    end
+
+    def text_area(
+      label,
+      value: UNSET,
+      error: UNSET,
+      model: UNSET,
+      bind: UNSET,
+      &action
+    )
+      value, error, action = resolve_binding(
+        model:, bind:, value:, error:, action:, default: ""
+      )
+      add TextArea.new(control_id("text-area"), label, value:, error:, action:)
+    end
+
+    def checkbox(
+      label,
+      checked: UNSET,
+      error: UNSET,
+      model: UNSET,
+      bind: UNSET,
+      &action
+    )
+      checked, error, action = resolve_binding(
+        model:, bind:, value: checked, error:, action:, default: false
+      )
+      add Checkbox.new(control_id("checkbox"), label, checked:, error:, action:)
+    end
+
+    def select(
+      label,
+      options:,
+      value: UNSET,
+      error: UNSET,
+      model: UNSET,
+      bind: UNSET,
+      &action
+    )
+      value, error, action = resolve_binding(
+        model:, bind:, value:, error:, action:, default: nil
+      )
+      add Select.new(control_id("select"), label, options:, value:, error:, action:)
+    end
+
+    def radio(
+      label,
+      options:,
+      value: UNSET,
+      error: UNSET,
+      model: UNSET,
+      bind: UNSET,
+      &action
+    )
+      value, error, action = resolve_binding(
+        model:, bind:, value:, error:, action:, default: nil
+      )
+      add Radio.new(control_id("radio"), label, options:, value:, error:, action:)
+    end
+
+    def file_field(label, error: nil, &action)
+      add FileField.new(control_id("file-field"), label, error:, action:)
+    end
+
+    def button(content, &action)
+      add Button.new(control_id("button"), content, action:)
+    end
+
+    def submit(content, &action)
+      unless @containers.any? { |container| container.is_a?(Form) }
+        raise ArgumentError, "submit must be inside a form"
+      end
+
+      add Submit.new(control_id("submit"), content, action:)
+    end
+
+    def strong(content)
+      Strong.new(content)
+    end
+
+    def em(content)
+      Emphasis.new(content)
+    end
+
+    def stack(&block)
+      container Stack.new, &block
+    end
+
+    def flow(&block)
+      container Flow.new, &block
+    end
+
+    def form(&block)
+      if @containers.any? { |container| container.is_a?(Form) }
+        raise ArgumentError, "forms cannot be nested"
+      end
+
+      container Form.new, &block
+    end
+
+    private
+
+    def add(element)
+      @containers.last.children << element
+      element
+    end
+
+    def container(element)
+      add element
+      @containers << element
+      yield
+      element
+    ensure
+      @containers.pop
+    end
+
+    def control_id(prefix)
+      id = "#{prefix}-#{@next_control_id}"
+      @next_control_id += 1
+      id
+    end
+
+    def resolve_binding(model:, bind:, value:, error:, action:, default:)
+      BindingResolver.resolve(
+        model:, bind:, value:, error:, action:, default:
+      ).deconstruct
+    end
+  end
+
+  class Container
+    attr_reader :children
+
+    def initialize
+      @children = []
+    end
+  end
+
+  class Stack < Container; end
+  class Flow < Container; end
+  class Form < Container; end
+
+  class Title
+    attr_reader :content
+
+    def initialize(content)
+      @content = content.to_s
+    end
+  end
+
+  class Subtitle
+    attr_reader :content
+
+    def initialize(content)
+      @content = content.to_s
+    end
+  end
+
+  class Para
+    attr_reader :parts
+
+    def initialize(parts)
+      @parts = parts
+    end
+  end
+
+  class Error
+    attr_reader :content
+
+    def initialize(content)
+      @content = content.to_s
+    end
+  end
+
+  class Notice
+    attr_reader :content
+
+    def initialize(content)
+      @content = content.to_s
+    end
+  end
+
+  class Image
+    attr_reader :source, :alt
+
+    def initialize(source, alt:)
+      @source = source.to_s
+      @alt = alt.to_s
+    end
+  end
+
+  class Link
+    ALLOWED_SCHEMES = %w[http https mailto].freeze
+
+    attr_reader :content, :destination
+
+    def initialize(content, to:)
+      @content = content.to_s
+      @destination = to.to_s
+      validate_destination
+    end
+
+    private
+
+    def validate_destination
+      uri = URI.parse(destination)
+      valid_http = uri.is_a?(URI::HTTP) && uri.host
+      valid_mail = uri.scheme == "mailto" && !uri.opaque.to_s.empty?
+      return if ALLOWED_SCHEMES.include?(uri.scheme) && (valid_http || valid_mail)
+
+      raise ArgumentError,
+        "link destination must be an external HTTP, HTTPS, or mailto URL"
+    rescue URI::InvalidURIError
+      raise ArgumentError,
+        "link destination must be an external HTTP, HTTPS, or mailto URL"
+    end
+  end
+
+  module FieldValidation
+    attr_reader :error
+
+    def invalid?
+      !error.nil?
+    end
+
+    def error_id
+      "#{id}-error"
+    end
+
+    private
+
+    def initialize_error(error)
+      @error =
+        if error.is_a?(Array)
+          error.map(&:to_s).join(", ")
+        else
+          error&.to_s
+        end
+    end
+  end
+
+  class TextField
+    include FieldValidation
+    include Actionable
+
+    attr_reader :id, :label, :value
+
+    def initialize(id, label, value:, action:, error: nil)
+      @id = id
+      @label = label.to_s
+      @value = value.to_s
+      initialize_error(error)
+      @action = action
+    end
+
+    def change(value)
+      execute_action(value)
+    end
+  end
+
+  class NumberField
+    include FieldValidation
+    include Actionable
+
+    attr_reader :id, :label, :value
+
+    def initialize(id, label, value:, action:, error: nil)
+      @id = id
+      @label = label.to_s
+      @value = value
+      initialize_error(error)
+      @action = action
+    end
+
+    def change(value)
+      execute_action(number(value))
+    end
+
+    private
+
+    def number(value)
+      return nil if value.nil? || value.empty?
+
+      Integer(value, exception: false) ||
+        Float(value, exception: false) ||
+        raise(ArgumentError, "invalid number: #{value}")
+    end
+  end
+
+  class TextArea
+    include FieldValidation
+    include Actionable
+
+    attr_reader :id, :label, :value
+
+    def initialize(id, label, value:, action:, error: nil)
+      @id = id
+      @label = label.to_s
+      @value = value.to_s
+      initialize_error(error)
+      @action = action
+    end
+
+    def change(value)
+      execute_action(value)
+    end
+  end
+
+  class Checkbox
+    include FieldValidation
+    include Actionable
+
+    attr_reader :id, :label
+
+    def initialize(id, label, checked:, action:, error: nil)
+      @id = id
+      @label = label.to_s
+      @checked = checked
+      initialize_error(error)
+      @action = action
+    end
+
+    def checked?
+      @checked
+    end
+
+    def change(checked)
+      execute_action(checked)
+    end
+  end
+
+  class Select
+    include FieldValidation
+    include Actionable
+
+    Option = Data.define(:value, :label)
+
+    attr_reader :id, :label, :options, :value
+
+    def initialize(id, label, options:, value:, action:, error: nil)
+      @id = id
+      @label = label.to_s
+      @options = normalize(options)
+      @value = value
+      initialize_error(error)
+      @action = action
+      validate_unique_values
+    end
+
+    def change(value)
+      option = @options.find { |candidate| candidate.value.to_s == value }
+      raise ArgumentError, "unknown select value: #{value}" unless option
+
+      execute_action(option.value)
+    end
+
+    def selected?(option)
+      option.value == value
+    end
+
+    private
+
+    def normalize(options)
+      if options.is_a?(Hash)
+        options.map do |value, label|
+          Option.new(value, label.to_s)
+        end
+      else
+        options.map do |value|
+          Option.new(value, value.to_s)
+        end
+      end
+    end
+
+    def validate_unique_values
+      values = @options.map { |option| option.value.to_s }
+      return if values.uniq.length == values.length
+
+      raise ArgumentError, "select values must be unique after serialization"
+    end
+  end
+
+  class Radio < Select; end
+
+  class FileField
+    include FieldValidation
+    include Actionable
+
+    attr_reader :id, :label
+
+    def initialize(id, label, action:, error: nil)
+      @id = id
+      @label = label.to_s
+      initialize_error(error)
+      @action = action
+    end
+
+    def change(file)
+      execute_action(file)
+    end
+  end
+
+  class Button
+    include Actionable
+
+    attr_reader :id, :content
+
+    def initialize(id, content, action:)
+      @id = id
+      @content = content.to_s
+      @action = action
+    end
+
+    def activate
+      execute_action
+    end
+  end
+
+  class Submit < Button
+    def submit
+      activate
+    end
+  end
+
+  class Strong
+    attr_reader :content
+
+    def initialize(content)
+      @content = content.to_s
+    end
+  end
+
+  class Emphasis
+    attr_reader :content
+
+    def initialize(content)
+      @content = content.to_s
+    end
+  end
+
+  class Table
+    FORBIDDEN_CELL_TYPES = [
+      Container,
+      TextField,
+      NumberField,
+      TextArea,
+      Checkbox,
+      Select,
+      FileField,
+      Button,
+      Title,
+      Subtitle,
+      Para,
+      Error,
+      Notice,
+      Image,
+      Link
+    ].freeze
+
+    attr_reader :headers, :rows
+
+    def initialize(headers:, rows:)
+      @headers = collection(headers, "table headers").map(&:to_s).freeze
+      @rows = collection(rows, "table rows").each_with_index.map do |row, index|
+        cells = collection(row, "table row #{index + 1}")
+        unless cells.length == @headers.length
+          raise ArgumentError,
+            "table row #{index + 1} has #{cells.length} cells, " \
+            "but #{@headers.length} headers were provided"
+        end
+
+        cells.map { |cell| normalize_cell(cell) }.freeze
+      end.freeze
+    end
+
+    private
+
+    def collection(value, name)
+      return value.to_a if value.respond_to?(:to_a) && !value.is_a?(String)
+
+      raise ArgumentError, "#{name} must be a collection"
+    end
+
+    def normalize_cell(cell)
+      if cell.is_a?(Table) ||
+          FORBIDDEN_CELL_TYPES.any? { |type| cell.is_a?(type) }
+        raise ArgumentError, "table cells cannot contain #{cell.class}"
+      end
+
+      return cell if cell.is_a?(Strong) || cell.is_a?(Emphasis)
+
+      cell.to_s
+    end
+  end
+end

data/lib/sandals.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "sandals/version"
+require_relative "sandals/binding_resolver"
+require_relative "sandals/action_error"
+require_relative "sandals/uploaded_file"
+require_relative "sandals/view"
+require_relative "sandals/html_renderer"
+require_relative "sandals/snapshot_history"
+require_relative "sandals/event_dispatcher"
+require_relative "sandals/application"
+require_relative "sandals/test_session"
+require_relative "sandals/code_reloader"
+require_relative "sandals/server"
+
+module Sandals
+  class << self
+    attr_reader :application
+
+    def app(title: "Sandals", &block)
+      @application = Application.new(title:, &block)
+    end
+
+    def load(path)
+      @application = nil
+      Kernel.load(File.expand_path(path))
+      application || raise(ArgumentError, "#{path} does not define Sandals.app")
+    end
+
+    def test(application)
+      TestSession.new(application)
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: sandals
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Benito Serna
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: |-
+  Sandals is a small local runtime for building interactive applications in
+  ordinary Ruby without writing HTML or JavaScript.
+executables:
+- sandals
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/sandals
+- lib/sandals.rb
+- lib/sandals/action_error.rb
+- lib/sandals/application.rb
+- lib/sandals/assets/TURBO-LICENSE
+- lib/sandals/assets/turbo.es2017-umd.js
+- lib/sandals/binding_resolver.rb
+- lib/sandals/cli.rb
+- lib/sandals/code_reloader.rb
+- lib/sandals/event_dispatcher.rb
+- lib/sandals/html_renderer.rb
+- lib/sandals/server.rb
+- lib/sandals/snapshot_history.rb
+- lib/sandals/test_session.rb
+- lib/sandals/uploaded_file.rb
+- lib/sandals/version.rb
+- lib/sandals/view.rb
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Build small interactive applications using only Ruby
+test_files: []