quince 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2cb965782c941f40df31a058388f1c7e30864c5a1cf708f2840340bf014a3b16
+  data.tar.gz: 235e3aa8b1a759799f996f2d2170582f628ac32a80a69bd4fab2838d91dd3a03
+SHA512:
+  metadata.gz: 8de7ca420355f54e90e5dc16517f670a6009ebf0d02f6fa45bbeddf2b92fb8eb9e05f8b1e1f9eec584aa6e283b9063146b8980b4b6c2b1463b4b104f6c967865
+  data.tar.gz: 0ac305e40cab122d9865e030572c704897a8daa5f2fa1dbb6222976834690be58efe1c4a5e1049b3f1e86846af584795ff41c2eb547490783d626544db677100

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in quince.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    quince (0.1.0)
+      oj (~> 3.13)
+      typed_struct (>= 0.1.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.4.4)
+    oj (3.13.5)
+    rake (13.0.6)
+    rbs (1.6.2)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    typed_struct (0.1.4)
+      rbs (~> 1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  quince!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Joseph Johansen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Quince
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/quince`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'quince'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install quince
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/quince.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "quince"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/quince/attributes_by_element.rb

@@ -0,0 +1,476 @@
+# frozen_string_literal: true
+
+require_relative "types"
+
+module Quince
+  module HtmlTagComponents
+    referrer_policy = Rbs("'' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url' | Quince::Types::Undefined")
+    form_method = Rbs(
+      '"get" | "post" | "GET" | "POST" | :GET | :POST | :get | :post | Quince::Types::Undefined'
+    )
+    t = Quince::Types
+    opt_string_sym = Rbs("#{t::OptionalString} | Symbol")
+    opt_bool = t::OptionalBoolean
+    opt_method = Rbs("Method | Quince::Types::Undefined")
+    value = opt_string_sym # for now
+
+    ATTRIBUTES_BY_ELEMENT = {
+      "A" => {
+        href: opt_string_sym,
+        hreflang: opt_string_sym,
+        media: opt_string_sym,
+        ping: opt_string_sym,
+        rel: opt_string_sym,
+        target: opt_string_sym,
+        type: opt_string_sym,
+        referrerpolicy: referrer_policy,
+      }.freeze,
+      "Abbr" => {}.freeze,
+      "Address" => {}.freeze,
+      "Article" => {}.freeze,
+      "Aside" => {}.freeze,
+      "Audio" => {
+        autoplay: opt_bool,
+        controls: opt_bool,
+        controlslist: opt_string_sym,
+        crossorigin: opt_string_sym,
+        loop: opt_bool,
+        mediagroup: opt_string_sym,
+        muted: opt_bool,
+        playsinline: opt_bool,
+        preload: opt_string_sym,
+        src: opt_string_sym,
+      }.freeze,
+      "B" => {}.freeze,
+      "Bdo" => {}.freeze,
+      "Blockquote" => {
+        cite: opt_string_sym,
+      }.freeze,
+      "Body" => {}.freeze,
+      "Button" => {
+        autofocus: opt_bool,
+        disabled: opt_bool,
+        form: opt_string_sym,
+        formaction: opt_string_sym,
+        formenctype: opt_string_sym,
+        formmethod: form_method,
+        formnovalidate: opt_bool,
+        formtarget: opt_string_sym,
+        name: opt_string_sym,
+        type: Rbs("'submit' | 'reset' | 'button' | Quince::Types::Undefined"),
+        value: value,
+      }.freeze,
+      "Canvas" => {
+        height: opt_string_sym,
+        width: opt_string_sym,
+      }.freeze,
+      "Caption" => {}.freeze,
+      "Cite" => {}.freeze,
+      "Code" => {}.freeze,
+      "Command" => {}.freeze,
+      "Colgroup" => {
+        span: opt_string_sym,
+      }.freeze,
+      "Data" => {
+        value: value,
+      }.freeze,
+      "Datalist" => {}.freeze,
+      "Dd" => {}.freeze,
+      "Del" => {
+        cite: opt_string_sym,
+        datetime: opt_string_sym,
+      }.freeze,
+      "Details" => {
+        open: opt_bool,
+      # ontoggle: Quince::Types::OptionalMethod;
+      }.freeze,
+      "Dfn" => {}.freeze,
+      "Dialog" => {
+        open: opt_bool,
+      }.freeze,
+      "Div" => {}.freeze,
+      "Dl" => {}.freeze,
+      "Dt" => {}.freeze,
+      "Em" => {}.freeze,
+      "Fieldset" => {
+        disabled: opt_bool,
+        form: opt_string_sym,
+        name: opt_string_sym,
+      }.freeze,
+      "Figcaption" => {}.freeze,
+      "Figure" => {}.freeze,
+      "Form" => {
+        "accept-charset": opt_string_sym,
+        action: opt_string_sym,
+        autocomplete: opt_string_sym,
+        enctype: opt_string_sym,
+        Method: form_method,
+        name: opt_string_sym,
+        novalidate: opt_bool,
+        target: opt_string_sym,
+      }.freeze,
+      "Footer" => {}.freeze,
+      "H1" => {}.freeze,
+      "H2" => {}.freeze,
+      "H3" => {}.freeze,
+      "H4" => {}.freeze,
+      "H5" => {}.freeze,
+      "H6" => {}.freeze,
+      "Head" => {}.freeze,
+      "Header" => {}.freeze,
+      "Html" => {
+        manifest: opt_string_sym,
+      }.freeze,
+      "I" => {}.freeze,
+      "Iframe" => {
+        allow: opt_string_sym,
+        allowfullscreen: opt_bool,
+        allowtransparency: opt_bool,
+        height: opt_string_sym,
+        loading: Rbs('"eager" | "lazy" | Quince::Types::Undefined'),
+        name: opt_string_sym,
+        referrerpolicy: referrer_policy,
+        sandbox: opt_string_sym,
+        seamless: opt_bool,
+        src: opt_string_sym,
+        srcdoc: opt_string_sym,
+        width: opt_string_sym,
+      }.freeze,
+      "Ins" => {
+        cite: opt_string_sym,
+        datetime: opt_string_sym,
+      }.freeze,
+      "Kbd" => {}.freeze,
+      "Keygen" => {
+        autofocus: opt_bool,
+        challenge: opt_string_sym,
+        disabled: opt_bool,
+        form: opt_string_sym,
+        keytype: opt_string_sym,
+        keyparams: opt_string_sym,
+        name: opt_string_sym,
+      }.freeze,
+      "Label" => {
+        form: opt_string_sym,
+        for: opt_string_sym,
+      }.freeze,
+      "Legend" => {}.freeze,
+      "Li" => {
+        value: value,
+      }.freeze,
+      "Main" => {},
+      "Map" => {
+        name: opt_string_sym,
+      }.freeze,
+      "Mark" => {}.freeze,
+      "Menu" => {
+        type: opt_string_sym,
+      }.freeze,
+      "Meter" => {
+        form: opt_string_sym,
+        high: opt_string_sym,
+        low: opt_string_sym,
+        Max: opt_string_sym,
+        Min: opt_string_sym,
+        optimum: opt_string_sym,
+        value: value,
+      }.freeze,
+      "Nav" => {}.freeze,
+      "Noscript" => {}.freeze,
+      "Object" => {
+        classid: opt_string_sym,
+        data: opt_string_sym,
+        form: opt_string_sym,
+        height: opt_string_sym,
+        name: opt_string_sym,
+        type: opt_string_sym,
+        usemap: opt_string_sym,
+        width: opt_string_sym,
+        wmode: opt_string_sym,
+      }.freeze,
+      "Ol" => {
+        reversed: opt_bool,
+        start: opt_string_sym,
+        type: Rbs("'1' | 'a' | 'A' | 'i' | 'I' | Quince::Types::Undefined"),
+      }.freeze,
+      "Optgroup" => {
+        disabled: opt_bool,
+        label: opt_string_sym,
+      }.freeze,
+      "Option" => {
+        disabled: opt_bool,
+        label: opt_string_sym,
+        selected: opt_bool,
+        value: value,
+      }.freeze,
+      "Output" => {
+        form: opt_string_sym,
+        for: opt_string_sym,
+        name: opt_string_sym,
+      }.freeze,
+      "Para" => {}, # for "p" element, in order not to clash with Ruby's common `p` method
+      "Pre" => {}.freeze,
+      "Progress" => {
+        Max: opt_string_sym,
+        value: value,
+      }.freeze,
+      "Q" => {}.freeze,
+      "Quote" => {
+        cite: opt_string_sym,
+      }.freeze,
+      "Rp" => {}.freeze,
+      "Rt" => {}.freeze,
+      "Ruby" => {}.freeze,
+      "S" => {}.freeze,
+      "Samp" => {}.freeze,
+      "Script" => {
+        async: opt_bool,
+        crossorigin: opt_string_sym,
+        defer: opt_bool,
+        integrity: opt_string_sym,
+        nomodule: opt_bool,
+        nonce: opt_string_sym,
+        referrerpolicy: referrer_policy,
+        src: opt_string_sym,
+        type: opt_string_sym,
+      }.freeze,
+      "Section" => {}.freeze,
+      "Select" => {
+        autocomplete: opt_string_sym,
+        autofocus: opt_bool,
+        disabled: opt_bool,
+        form: opt_string_sym,
+        multiple: opt_bool,
+        name: opt_string_sym,
+        required: opt_bool,
+        Size: opt_string_sym,
+        value: value,
+      # onchange: Rbs::Types::OptionalMethod,
+      }.freeze,
+      "Small" => {}.freeze,
+      "Span" => {}.freeze,
+      "Strong" => {}.freeze,
+      "Slot" => {
+        name: opt_string_sym,
+      }.freeze,
+      "Style" => {
+        media: opt_string_sym,
+        nonce: opt_string_sym,
+        scoped: opt_bool,
+        type: opt_string_sym,
+      }.freeze,
+      "Sub" => {}.freeze,
+      "Sup" => {}.freeze,
+      "Table" => {
+        cellpadding: opt_string_sym,
+        cellspacing: opt_string_sym,
+        summary: opt_string_sym,
+        width: opt_string_sym,
+      }.freeze,
+      "Tbody" => {}.freeze,
+      "Td" => {
+        align: Rbs('"left" | "center" | "right" | "justify" | "char" | Quince::Types::Undefined'),
+        colspan: opt_string_sym,
+        headers: opt_string_sym,
+        rowspan: opt_string_sym,
+        scope: opt_string_sym,
+        abbr: opt_string_sym,
+        height: opt_string_sym,
+        width: opt_string_sym,
+        valign: Rbs('"top" | "middle" | "bottom" | "baseline" | Quince::Types::Undefined'),
+      }.freeze,
+      "Textarea" => {
+        autocomplete: opt_string_sym,
+        autofocus: opt_bool,
+        cols: opt_string_sym,
+        dirname: opt_string_sym,
+        disabled: opt_bool,
+        form: opt_string_sym,
+        maxlength: opt_string_sym,
+        minlength: opt_string_sym,
+        name: opt_string_sym,
+        placeholder: opt_string_sym,
+        readonly: opt_bool,
+        required: opt_bool,
+        rows: opt_string_sym,
+        value: value,
+        wrap: opt_string_sym,
+      # onchange: Rbs::Types::OptionalMethod,
+      }.freeze,
+      "Tfoot" => {}.freeze,
+      "Th" => {
+        align: Rbs('"left" | "center" | "right" | "justify" | "char" | Quince::Types::Undefined'),
+        colspan: opt_string_sym,
+        headers: opt_string_sym,
+        rowspan: opt_string_sym,
+        scope: opt_string_sym,
+        abbr: opt_string_sym,
+      }.freeze,
+      "Thead" => {}.freeze,
+      "Title" => {}.freeze,
+      "Time" => {
+        datetime: opt_string_sym,
+      }.freeze,
+      "Tr" => {}.freeze,
+      "U" => {}.freeze,
+      "Ul" => {}.freeze,
+      "Var" => {}.freeze,
+      "Video" => {
+        autoplay: opt_bool,
+        controls: opt_bool,
+        controlslist: opt_string_sym,
+        crossorigin: opt_string_sym,
+        height: opt_string_sym,
+        loop: opt_bool,
+        mediagroup: opt_string_sym,
+        muted: opt_bool,
+        playsinline: opt_bool,
+        poster: opt_string_sym,
+        preload: opt_string_sym,
+        src: opt_string_sym,
+        width: opt_string_sym,
+      }.freeze,
+    }.freeze
+
+    SELF_CLOSING_TAGS = {
+      "Area" => {
+        alt: opt_string_sym,
+        coords: opt_string_sym,
+        download: t::Any,
+        href: opt_string_sym,
+        hreflang: opt_string_sym,
+        media: opt_string_sym,
+        referrerpolicy: referrer_policy,
+        rel: opt_string_sym,
+        shape: opt_string_sym,
+        target: opt_string_sym,
+      }.freeze,
+      "Base" => {
+        href: opt_string_sym,
+        target: opt_string_sym,
+      }.freeze,
+      "Br" => {}.freeze,
+      "Col" => {
+        span: opt_string_sym,
+        width: opt_string_sym,
+      }.freeze,
+      "Embed" => {
+        height: opt_string_sym,
+        src: opt_string_sym,
+        type: opt_string_sym,
+        width: opt_string_sym,
+      }.freeze,
+      "Hr" => {}.freeze,
+      "Img" => {
+        alt: opt_string_sym,
+        crossorigin: Rbs('"anonymous" | "use-credentials" | "" | Quince::Types::Undefined'),
+        decoding: Rbs('"async" | "auto" | "sync" | Quince::Types::Undefined'),
+        height: Rbs("#{opt_string_sym} | Integer"),
+        loading: Rbs('"eager" | "lazy" | Quince::Types::Undefined'),
+        referrerpolicy: referrer_policy,
+        sizes: opt_string_sym,
+        src: opt_string_sym,
+        srcSet: opt_string_sym,
+        useMap: opt_string_sym,
+        width: Rbs("#{opt_string_sym} | Integer"),
+      }.freeze,
+      "Input" => {
+        accept: opt_string_sym,
+        alt: opt_string_sym,
+        autocomplete: opt_string_sym,
+        autofocus: opt_bool,
+        capture: Rbs("String | #{opt_bool}"),
+        checked: opt_bool,
+        crossorigin: opt_string_sym,
+        disabled: opt_bool,
+        form: opt_string_sym,
+        formaction: opt_string_sym,
+        formenctype: opt_string_sym,
+        formmethod: form_method,
+        formnovalidate: opt_bool,
+        formtarget: opt_string_sym,
+        height: opt_string_sym,
+        list: opt_string_sym,
+        Max: opt_string_sym,
+        maxlength: opt_string_sym,
+        Min: opt_string_sym,
+        minlength: opt_string_sym,
+        multiple: opt_bool,
+        name: opt_string_sym,
+        pattern: opt_string_sym,
+        placeholder: opt_string_sym,
+        readonly: opt_bool,
+        required: opt_bool,
+        Size: opt_string_sym,
+        src: opt_string_sym,
+        step: opt_string_sym,
+        type: opt_string_sym,
+        value: value,
+        width: opt_string_sym,
+      # onchange: Rbs::Types::OptionalMethod,
+      }.freeze,
+      "Link" => {
+        as: opt_string_sym,
+        crossorigin: opt_string_sym,
+        href: opt_string_sym,
+        hreflang: opt_string_sym,
+        integrity: opt_string_sym,
+        media: opt_string_sym,
+        referrerpolicy: referrer_policy,
+        rel: opt_string_sym,
+        sizes: opt_string_sym,
+        type: opt_string_sym,
+        charset: opt_string_sym,
+      }.freeze,
+      "Meta" => {
+        charSet: opt_string_sym,
+        content: opt_string_sym,
+        "http-equiv": opt_string_sym,
+        name: opt_string_sym,
+      }.freeze,
+      "Param" => {
+        name: opt_string_sym,
+        value: value,
+      }.freeze,
+      "Source" => {
+        media: opt_string_sym,
+        sizes: opt_string_sym,
+        src: opt_string_sym,
+        srcset: opt_string_sym,
+        type: opt_string_sym,
+      }.freeze,
+      "Track" => {
+        default: opt_bool,
+        kind: opt_string_sym,
+        label: opt_string_sym,
+        src: opt_string_sym,
+        srclang: opt_string_sym,
+      }.freeze,
+      "Wbr" => {}.freeze,
+    }.freeze
+
+    GLOBAL_HTML_ATTRS = {
+      accesskey: opt_string_sym,
+      Class: opt_string_sym,
+      contenteditable: opt_string_sym,
+      # data-*: opt_string_sym,
+      dir: opt_string_sym,
+      draggable: opt_string_sym,
+      hidden: opt_string_sym,
+      id: opt_string_sym,
+      lang: opt_string_sym,
+      spellcheck: opt_string_sym,
+      style: opt_string_sym,
+      tabindex: opt_string_sym,
+      title: opt_string_sym,
+      translate: opt_string_sym,
+    }.freeze
+
+    DOM_EVENTS = {
+      onclick: opt_method,
+      onsubmit: opt_method,
+    }.freeze
+  end
+end
+
+Undefined = Quince::Types::Undefined

data/lib/quince/component.rb

@@ -0,0 +1,90 @@
+module Quince
+  class Component
+    class << self
+      def inherited(subclass)
+        Quince.define_constructor(subclass)
+      end
+
+      def Props(**kw)
+        self.const_set "Props", TypedStruct.new(
+          { default: Quince::Types::Undefined },
+          Quince::Component::HTML_SELECTOR_ATTR => String,
+          **kw,
+        )
+      end
+
+      def State(**kw)
+        st = kw.empty? ? nil : TypedStruct.new(
+          { default: Quince::Types::Undefined },
+          **kw,
+        )
+        self.const_set "State", st
+      end
+
+      def exposed(action, meth0d: :POST)
+        @exposed_actions ||= Set.new
+        @exposed_actions.add action
+        route = "/api/#{self.name}/#{action}"
+        Quince.middleware.create_route_handler(
+          verb: meth0d,
+          route: route,
+        ) do |params|
+          instance = Quince::Serialiser.deserialise params[:component]
+          if @exposed_actions.member? action
+            if instance.method(action).arity.zero?
+              instance.send action
+            else
+              instance.send action, params[:params]
+            end
+            instance
+          else
+            raise "The action you called is not exposed"
+          end
+        end
+
+        route
+      end
+
+      def initial_state=(attrs)
+        @initial_state ||= self::State.new(**attrs)
+      end
+
+      attr_reader :initial_state
+
+      private
+
+      def initialize_props(const, id, **props)
+        const::Props.new(HTML_SELECTOR_ATTR => id, **props) if const.const_defined?("Props")
+      end
+    end
+
+    attr_reader :props, :state, :children
+
+    def initialize(*children, **props, &block_children)
+      @__id = SecureRandom.alphanumeric(6)
+      @props = self.class.send :initialize_props, self.class, @__id, **props
+      @state = self.class.initial_state
+      @children = block_children || children
+    end
+
+    def render
+      raise "not implemented"
+    end
+
+    protected
+
+    def to(route, via: :POST)
+      self.class.exposed route, meth0d: via
+    end
+
+    private
+
+    attr_reader :__id
+
+    HTML_SELECTOR_ATTR = :"data-respid"
+
+    def html_element_selector
+      "[#{HTML_SELECTOR_ATTR}='#{__id}']".freeze
+    end
+  end
+end

data/lib/quince/html_tag_components.rb

@@ -0,0 +1,102 @@
+require "oj"
+require_relative "attributes_by_element"
+require_relative "serialiser"
+
+module Quince
+  module HtmlTagComponents
+    def self.define_html_tag_component(const_name, attrs, self_closing: false)
+      klass = Class.new(Quince::Component) do
+        Props(
+          **GLOBAL_HTML_ATTRS,
+          **DOM_EVENTS,
+          **attrs,
+        )
+
+        def render
+          attrs = if props
+              props.each_pair.map { |k, v| to_html_attr(k, v) }.compact.join(" ")
+            end
+          result = "<#{tag_name}"
+          result << " #{attrs}>" unless attrs.empty?
+
+          return result if self_closing?
+
+          result << Quince.to_html(children)
+          result << "</#{tag_name}>"
+          result
+        end
+
+        def to_html_attr(key, value)
+          # for attribute names which clash with standard ruby method
+          # eg :class, the first letter is capitalised
+          key[0].downcase!
+          attrib = case value
+            when String, Integer, Float, Symbol
+              value.to_s
+            when Method
+              owner = value.owner
+              receiver = value.receiver
+              name = value.name
+              selector = receiver.send :html_element_selector
+              internal = Quince::Serialiser.serialise receiver
+              payload = { component: internal }.to_json
+              case key
+              when :onclick
+                CGI.escape_html(
+                  "callRemoteEndpoint(`/api/#{owner}/#{name}`,`#{payload}`,`#{selector}`)"
+                )
+              when :onsubmit
+                CGI.escape_html(
+                  "const p = #{payload}; callRemoteEndpoint( `/api/#{owner}/#{name}`, JSON.stringify({...p, params: getFormValues(this)}), `#{selector}`); return false"
+                )
+              end
+            when true
+              return key
+            when false, nil, Quince::Types::Undefined
+              return ""
+            else
+              raise "prop type not yet implemented #{value}"
+            end
+
+          %Q{#{key}="#{attrib}"}
+        end
+
+        def tag_name
+          @tag_name ||= self.class::TAG_NAME
+        end
+
+        def self_closing?
+          @self_closing ||= self.class::SELF_CLOSING
+        end
+      end
+
+      lower_tag = const_name.downcase
+      klass.const_set("TAG_NAME", lower_tag == "para" ? "p".freeze : lower_tag.freeze)
+      klass.const_set "SELF_CLOSING", self_closing
+
+      HtmlTagComponents.const_set const_name, klass
+
+      Quince.define_constructor HtmlTagComponents.const_get(const_name), lower_tag
+    end
+    private_class_method :define_html_tag_component
+
+    ATTRIBUTES_BY_ELEMENT.each { |t, attrs| define_html_tag_component(t, attrs) }
+    SELF_CLOSING_TAGS.each { |t, attrs| define_html_tag_component(t, attrs, self_closing: true) }
+
+    def internal_scripts
+      contents = File.read(File.join(__dir__, "..", "..", "scripts.js"))
+      script {
+        contents
+      }
+    end
+  end
+
+  Quince::Component.include HtmlTagComponents
+end
+
+# tmp hack
+class TypedStruct < Struct
+  def to_json(*args)
+    to_h.to_json(*args)
+  end
+end

data/lib/quince/serialiser.rb

@@ -0,0 +1,102 @@
+module Quince
+  class Serialiser
+    class << self
+      def serialise(obj)
+        val = case obj
+          when Quince::Component
+            {
+              id: serialise(obj.send(:__id)),
+              props: serialise(obj.props),
+              state: serialise(obj.state),
+              children: serialise(obj.children),
+              html_element_selector: serialise(obj.send(:html_element_selector)),
+            }
+          when Array
+            obj.map { |e| serialise e }
+          when TypedStruct, Struct, OpenStruct, Hash
+            result = obj.each_pair.each_with_object({}) do |(k, v), ob|
+              case v
+              when Undefined
+                next
+              else
+                ob[k] = serialise(v)
+              end
+            end
+            if result.empty? && !obj.is_a?(Hash)
+              obj = nil
+              nil
+            else
+              result
+            end
+          when Proc
+            obj = obj.call # is there a more efficient way of doing this?
+            serialise(obj)
+          when String
+            res = obj.gsub "
+", "
+"
+            res.gsub! ?", '\"'
+            res
+          else
+            obj
+          end
+
+        { t: obj.class&.name, v: val }
+      end
+
+      def deserialise(json)
+        case json[:t]
+        when "String", "Integer", "Float", "NilClass", "TrueClass", "FalseClass"
+          json[:v]
+        when "Symbol"
+          json[:v].to_sym
+        when "Array"
+          json[:v].map { |e| deserialise e }
+        when "Hash"
+          transform_hash json[:v]
+        when "OpenStruct"
+          OpenStruct.new(**transform_hash(props))
+        when nil
+          nil
+        else
+          klass = Object.const_get(json[:t])
+          if klass < TypedStruct
+            transform_hash_for_struct(json[:v]) || {}
+          elsif klass < Quince::Component
+            instance = klass.allocate
+            val = json[:v]
+            id = deserialise val[:id]
+
+            instance.instance_variable_set :@__id, id
+            instance.instance_variable_set(
+              :@props,
+              klass.send(
+                :initialize_props,
+                klass,
+                id,
+                **(deserialise(val[:props]) || {}),
+              ),
+            )
+            st = deserialise(val[:state])
+            instance.instance_variable_set :@state, klass::State.new(**st) if st
+            instance.instance_variable_set :@children, deserialise(val[:children])
+            instance
+          else
+            klass = Object.const_get(json[:t])
+            klass.new(deserialise(json[:v]))
+          end
+        end
+      end
+
+      private
+
+      def transform_hash(hsh)
+        hsh.transform_values! { |v| deserialise v }
+      end
+
+      def transform_hash_for_struct(hsh)
+        hsh.to_h { |k, v| [k.to_sym, deserialise(v)] }
+      end
+    end
+  end
+end

data/lib/quince/singleton_methods.rb

@@ -0,0 +1,57 @@
+module Quince
+  class << self
+    attr_reader :middleware
+    attr_accessor :underlying_app
+
+    def optional_string
+      @optional_string ||= Rbs("String?")
+    end
+
+    def middleware=(middleware)
+      @middleware = middleware
+      Object.define_method(:expose) do |component, at:|
+        component = component.new if component.instance_of? Class
+
+        Quince.middleware.create_route_handler(
+          verb: :GET,
+          route: at,
+          component: component,
+        )
+      end
+    end
+
+    def define_constructor(const, constructor_name = const.to_s)
+      HtmlTagComponents.instance_eval do
+        define_method(constructor_name) do |*children, **props, &block_children|
+          new_props = { **props, Quince::Component::HTML_SELECTOR_ATTR => __id }
+          const.new(*children, **new_props, &block_children)
+        end
+      end
+    end
+
+    def to_html(component)
+      output = component
+
+      until output.is_a? String
+        case output
+        when Array
+          output = output.map { |c| to_html(c) }.join
+        when String
+          break
+        when Proc
+          output = to_html(output.call)
+        when NilClass
+          output = ""
+        else
+          tmp = output
+          output = output.render
+          if output.is_a?(Array)
+            raise "#render in #{tmp.class} should not return multiple elements. Consider wrapping it in a div"
+          end
+        end
+      end
+
+      output
+    end
+  end
+end

data/lib/quince/types.rb

@@ -0,0 +1,13 @@
+module Quince
+  module Types
+    class Base; end
+
+    # precompiled helper types
+    OptionalString = Rbs("String | Quince::Types::Undefined").freeze
+    OptionalBoolean = Rbs("true | false | Quince::Types::Undefined").freeze
+
+    # no functional value for now, other than constants
+    Undefined = Class.new(Base).new.freeze
+    Any = Class.new(Base).new.freeze
+  end
+end

data/lib/quince/version.rb

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

data/lib/quince.rb

@@ -0,0 +1,6 @@
+require "securerandom"
+require "typed_struct"
+require "cgi"
+require_relative "quince/singleton_methods"
+require_relative "quince/component"
+require_relative "quince/html_tag_components"

data/quince.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/quince/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "quince"
+  spec.version       = Quince::VERSION
+  spec.authors       = ["Joseph Johansen"]
+  spec.email         = ["joe@stotles.com"]
+
+  spec.summary       = "The ruby framework for building dynamic & stateful user experiences"
+  spec.description   = "Quince is an opinionated framework for building dynamic yet fully server-rendered web apps, with little to no JavaScript"
+  spec.homepage      = "https://github.com/johansenja/quince"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "typed_struct", ">= 0.1.4"
+  spec.add_dependency "oj", "~> 3.13"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: quince
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joseph Johansen
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typed_struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: Quince is an opinionated framework for building dynamic yet fully server-rendered
+  web apps, with little to no JavaScript
+email:
+- joe@stotles.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/quince.rb
+- lib/quince/attributes_by_element.rb
+- lib/quince/component.rb
+- lib/quince/html_tag_components.rb
+- lib/quince/serialiser.rb
+- lib/quince/singleton_methods.rb
+- lib/quince/types.rb
+- lib/quince/version.rb
+- quince.gemspec
+homepage: https://github.com/johansenja/quince
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/johansenja/quince
+  source_code_uri: https://github.com/johansenja/quince
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: The ruby framework for building dynamic & stateful user experiences
+test_files: []