rendry 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 020307f7389d6a1dcdde28eb61c2eaf4367c9d1848584d67b7665fe45a9804a5
+  data.tar.gz: 578e5969022b18f937daa40e5fd6419937c8afb906ee0614b1500bc95820c769
+SHA512:
+  metadata.gz: e8c0cd070c058b4ea029a9ffd2c831c50ae7547ac3006f65bf282899aec0e089cf09049dcd3996c370a6ca83abc51dd19aeda17a9829755c17c2e7cd6bba9fd8
+  data.tar.gz: 9aa71174fe35e25263de312dd46ff6dc3af4a6e45ca3dbde64a6d66f61476b6d37061eccf689a96bf6d3420adb009e0bca930c63f6bc8c5e0ea09cf0ba96a899

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rendry contributors
+
+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,122 @@
+# Rendry UI
+
+Rendry UI is a lightweight server-rendered UI framework for Ruby. It provides a small DSL for composing HTML with Ruby — explicit markup, safe escaping by default, testable components, and optional hypermedia interactivity with zero mandatory JavaScript.
+
+## Usage
+
+```ruby
+require_relative "lib/rendry"
+
+html = Rendry.render do
+  main(class: "page") do
+    h1 { text "Tasks" }
+    p "A simple Ruby interface"
+    button "Create task", type: "submit"
+  end
+end
+
+puts html
+```
+
+Values passed to `text` and element content are escaped automatically. Use `raw` only for an HTML fragment fully controlled by your application.
+
+## Components
+
+```ruby
+class Badge < Rendry::Component
+  def initialize(label)
+    @label = label
+  end
+
+  def render
+    Rendry.render { span(@label, class: "badge") }
+  end
+end
+
+Rendry.render { component Badge.new("Ready") }
+```
+
+Components keep access to their instance variables inside DSL blocks, and accept a content block via `do...end` or `{ }`.
+
+## Features
+
+### Layout
+
+`Rendry::Components::Layout` renders a full HTML document with `title:`, an optional `head:` block, and `view_transitions: true` for native cross-page transitions (pure CSS, no JS).
+
+### Hypermedia (`hx`)
+
+Build htmx attributes inline — Hash/Array values become JSON:
+
+```ruby
+button("Delete", **hx(delete: "/tasks/1", target: "closest .task"))
+# => hx-delete="/tasks/1" hx-target="closest .task"
+```
+
+Also available as `Rendry.hx` outside render blocks.
+
+### Selective fragments
+
+`fragment("name")` is transparent in normal renders. `Rendry.render(fragments: ["name"])` emits only the matching fragments — even nested inside components — for htmx swap endpoints.
+
+### Fragment cache
+
+`cache(*keys) { ... }` memoizes a DSL block in an in-memory FIFO store (`Rendry.cache_store`).
+
+### Refreshing components
+
+Declare polling once on the component class:
+
+```ruby
+class Comments < Rendry::Component
+  refreshes every: "10s", url: "/comments", target: "#comments"
+end
+```
+
+`component Comments.new(list)` is then wrapped in a `display:contents` div carrying the `hx-*` attributes. Override per call with `component X.new, refresh: { url: "/x" }`.
+
+### Kits
+
+Package components into a module:
+
+```ruby
+module Storefront
+  extend Rendry::Kit
+  component PriceTag   # => Storefront[:price_tag]
+end
+
+Storefront.render(:price_tag, "19.99")
+```
+
+`Rendry::Components` is itself a kit: `Rendry::Components[:button]`.
+
+## Examples
+
+`examples/` contains numbered, standalone mini-projects — see `examples/README.md`:
+
+| # | Project | Demo |
+|---|---------|------|
+| 01 | `01_static_page/` | DSL basics | 
+| 02 | `02_component_gallery/` | Components + built-in kit |
+| 03 | `03_layout_site/` | Multi-page site, view transitions |
+| 04 | `04_tasks_sinatra/` | Sinatra app, server state |
+| 05 | `05_htmx_tasks/` | htmx fragment swaps |
+| 06 | `06_fragments_cache/` | fragments + cache + `refreshes` |
+| 07 | `07_component_kit/` | `Rendry::Kit` packaging |
+
+```sh
+bundle exec rake          # tests
+bundle exec rake examples # smoke-run static examples
+ruby -Ilib test/test_rendry.rb
+```
+
+## Project direction
+
+The core targets four properties:
+
+- explicit, readable HTML;
+- safe escaping by default;
+- Ruby components that are easy to test;
+- no mandatory frontend dependency.
+
+This is not a complete web framework yet. Routing, forms, state management, and layout rendering currently belong to the host application, such as Sinatra.

data/lib/rendry/version.rb

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

data/lib/rendry.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "json"
+require_relative "rendry/version"
+
+module Rendry
+  class SafeHTML < String
+    def html_safe?
+      true
+    end
+  end
+
+  VOID_ELEMENTS = %w[area base br col embed hr img input link meta param source track wbr].freeze
+  BOOLEAN_ATTRIBUTES = %i[allowfullscreen async autofocus autoplay checked controls defer disabled formnovalidate hidden inert loop multiple muted nomodule novalidate open playsinline readonly required reversed selected].freeze
+
+  class Cache
+    def initialize(limit: 128)
+      @store = {}
+      @limit = limit
+    end
+
+    def fetch(key)
+      return @store[key] if @store.key?(key)
+
+      value = yield
+      @store[key] = value
+      @store.shift while @store.size > @limit
+      value
+    end
+
+    def clear
+      @store.clear
+    end
+  end
+
+  class Builder
+    attr_reader :output
+
+    def initialize(enabled: true)
+      @output = +""
+      @enabled = enabled
+    end
+
+    def render
+      @output
+    end
+
+    def text(value)
+      write CGI.escapeHTML(value.to_s)
+      self
+    end
+
+    def raw(value)
+      write value.to_s
+      self
+    end
+
+    def tag(name, content = nil, **attributes, &block)
+      if content.is_a?(Hash) && attributes.empty?
+        attributes = content
+        content = nil
+      end
+
+      if block
+        children = Builder.new(enabled: @enabled)
+        Rendry.evaluate(children, &block)
+        content = SafeHTML.new(children.render)
+      end
+
+      output = +"<#{name}#{format_attributes(attributes)}>"
+      unless VOID_ELEMENTS.include?(name.to_s)
+        output << (content.is_a?(SafeHTML) ? content : CGI.escapeHTML(content.to_s))
+        output << "</#{name}>"
+      end
+      write output
+      self
+    end
+
+    def fragment(name, &block)
+      filter = Rendry.current_fragments
+      if filter
+        return self unless filter.include?(name.to_s)
+
+        target = Rendry.root_builder || self
+        previous = target.instance_variable_get(:@enabled)
+        target.instance_variable_set(:@enabled, true)
+        begin
+          Rendry.evaluate(target, &block)
+        ensure
+          target.instance_variable_set(:@enabled, previous)
+        end
+      else
+        Rendry.evaluate(self, &block)
+      end
+      self
+    end
+
+    def cache(*keys, **_options, &block)
+      location = block.source_location.join(":")
+      key = "#{location}:#{keys.inspect}"
+      html = Rendry.cache_store.fetch(key) do
+        child = Builder.new(enabled: @enabled)
+        Rendry.evaluate(child, &block)
+        SafeHTML.new(child.render)
+      end
+      write html
+      self
+    end
+
+    def hx(**attributes)
+      Rendry.hx(**attributes)
+    end
+
+    def component(component_instance, refresh: nil, &block)
+      if block && component_instance.respond_to?(:block=) && !component_instance.instance_variable_get(:@block)
+        component_instance.block = block
+      end
+      rendered = component_instance.render
+      html = rendered.is_a?(SafeHTML) ? rendered : SafeHTML.new(CGI.escapeHTML(rendered.to_s))
+      config = refresh || (component_instance.class.refresh_config if component_instance.class.respond_to?(:refresh_config))
+      html = refresh_wrapper(html, config) if config
+      if @enabled
+        write html
+      elsif Rendry.current_fragments
+        @output << html
+      end
+      self
+    end
+
+    def p(content = nil, **attributes, &block)
+      tag("p", content, **attributes, &block)
+    end
+
+    def method_missing(name, content = nil, **attributes, &block)
+      if name.to_s.match?(/\A[a-z][a-z0-9_]*\z/)
+        tag(name.to_s.tr("_", "-"), content, **attributes, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name.to_s.match?(/\A[a-z][a-z0-9_]*\z/) || super
+    end
+
+    private
+
+    def write(string)
+      @output << string if @enabled
+    end
+
+    def refresh_wrapper(html, config)
+      attributes = {
+        class: "rendry-refresh",
+        style: "display:contents",
+        hx_get: config[:url],
+        hx_trigger: config[:trigger] || (config[:every] && "every #{config[:every]}") || "load",
+        hx_target: config[:target] || "this",
+        hx_swap: config[:swap] || "outerHTML"
+      }.compact
+      output = +"<div#{format_attributes(attributes)}>"
+      output << html
+      output << "</div>"
+      SafeHTML.new(output)
+    end
+
+    def format_attributes(attributes)
+      attributes.each_with_object(+"") do |(key, value), result|
+        next if value.nil? || value == false
+
+        attribute = key.to_s.tr("_", "-")
+        if BOOLEAN_ATTRIBUTES.include?(key.to_sym)
+          result << " #{attribute}"
+        else
+          result << %( #{attribute}="#{CGI.escapeHTML(value.to_s)}")
+        end
+      end
+    end
+  end
+
+  class Component
+    attr_writer :block
+
+    class << self
+      def refreshes(**config)
+        @refresh_config = config
+      end
+
+      def refresh_config
+        @refresh_config
+      end
+    end
+
+    def render
+      raise NotImplementedError, "#{self.class} must implement #render"
+    end
+  end
+
+  module Kit
+    def self.extended(base)
+      base.instance_variable_set(:@kit_components, {})
+    end
+
+    def component(klass, as: nil)
+      key = (as || klass.name.to_s.split("::").last).to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+      kit_components[key] = klass
+      klass
+    end
+
+    def [](name)
+      kit_components.fetch(name.to_sym) do
+        raise KeyError, "unknown component #{name.inspect} in #{self}"
+      end
+    end
+
+    def components
+      kit_components.dup
+    end
+
+    def render(name, *args, **kwargs, &block)
+      self[name].new(*args, **kwargs, &block).render
+    end
+
+    private
+
+    def kit_components
+      @kit_components ||= {}
+    end
+  end
+
+  # Built-in Standard UI Components Kit
+  module Components
+    class Layout < Component
+      def initialize(title: "Rendry", head: nil, view_transitions: false, **attributes, &block)
+        @title = title
+        @head = head
+        @view_transitions = view_transitions
+        @attributes = attributes
+        @block = block
+      end
+
+      def render
+        Rendry.render do
+          html(lang: "en", **@attributes) do
+            head do
+              meta(charset: "utf-8")
+              meta(name: "viewport", content: "width=device-width, initial-scale=1")
+              title(@title)
+              if @view_transitions
+                style { raw "@view-transition { navigation: auto; }" }
+              end
+              Rendry.evaluate(self, &@head) if @head
+            end
+            body do
+              Rendry.evaluate(self, &@block) if @block
+            end
+          end
+        end
+      end
+    end
+
+    class Button < Component
+      def initialize(label = nil, href: nil, variant: "primary", type: "button", **attributes, &block)
+        @label = label
+        @href = href
+        @variant = variant
+        @type = type
+        @attributes = attributes
+        @block = block
+      end
+
+      def render
+        css = "rendry-btn rendry-btn-#{@variant} #{@attributes[:class]}".strip
+        attrs = @attributes.except(:class)
+        if @href
+          Rendry.render do
+            a(href: @href, class: css, **attrs) do
+              @label ? text(@label) : (@block && Rendry.evaluate(self, &@block))
+            end
+          end
+        else
+          Rendry.render do
+            button(type: @type, class: css, **attrs) do
+              @label ? text(@label) : (@block && Rendry.evaluate(self, &@block))
+            end
+          end
+        end
+      end
+    end
+
+    class Badge < Component
+      def initialize(label, variant: "default", **attributes)
+        @label = label
+        @variant = variant
+        @attributes = attributes
+      end
+
+      def render
+        css = "rendry-badge rendry-badge-#{@variant} #{@attributes[:class]}".strip
+        Rendry.render do
+          span(@label, class: css, **@attributes.except(:class))
+        end
+      end
+    end
+
+    class Card < Component
+      def initialize(title: nil, **attributes, &block)
+        @title = title
+        @attributes = attributes
+        @block = block
+      end
+
+      def render
+        css = "rendry-card #{@attributes[:class]}".strip
+        Rendry.render do
+          div(class: css, **@attributes.except(:class)) do
+            h3(@title, class: "rendry-card-title") if @title
+            div(class: "rendry-card-body") do
+              if @block
+                Rendry.evaluate(self, &@block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    class Alert < Component
+      def initialize(message = nil, variant: "info", **attributes, &block)
+        @message = message
+        @variant = variant
+        @attributes = attributes
+        @block = block
+      end
+
+      def render
+        css = "rendry-alert rendry-alert-#{@variant} #{@attributes[:class]}".strip
+        Rendry.render do
+          div(class: css, role: "alert", **@attributes.except(:class)) do
+            text(@message) if @message
+            if @block
+              Rendry.evaluate(self, &@block)
+            end
+          end
+        end
+      end
+    end
+
+    extend Kit
+    component Layout
+    component Button
+    component Badge
+    component Card
+    component Alert
+  end
+
+  module_function
+
+  def hx(**attributes)
+    attributes.each_with_object({}) do |(key, value), result|
+      value = JSON.generate(value) if value.is_a?(Hash) || value.is_a?(Array)
+      result[:"hx-#{key.to_s.tr('_', '-')}"] = value
+    end
+  end
+
+  def cache_store
+    @cache_store ||= Cache.new
+  end
+
+  def current_fragments
+    @current_fragments
+  end
+
+  def root_builder
+    @root_builder
+  end
+
+  def render(fragments: nil, &block)
+    filter = fragments || @current_fragments
+    builder = Builder.new(enabled: filter.nil?)
+    if fragments
+      previous_fragments = @current_fragments
+      previous_root = @root_builder
+      @current_fragments = fragments.map(&:to_s)
+      @root_builder = builder
+      begin
+        evaluate(builder, &block)
+      ensure
+        @current_fragments = previous_fragments
+        @root_builder = previous_root
+      end
+    else
+      evaluate(builder, &block)
+    end
+    SafeHTML.new(builder.render)
+  end
+
+  def evaluate(builder, &block)
+    owner = block.binding.receiver
+    owner.instance_variables.each do |ivar|
+      next if ivar == :@output || ivar == :@enabled
+
+      builder.instance_variable_set(ivar, owner.instance_variable_get(ivar))
+    end
+    if block.lambda? && block.arity.zero?
+      builder.instance_exec(&block)
+    else
+      builder.instance_eval(&block)
+    end
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: rendry
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- NICE-DEV226
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Rendry UI is a small DSL for composing HTML with Ruby: explicit markup,
+  safe escaping by default, testable components, optional htmx
+  interactivity, selective fragments, fragment caching, and component kits —
+  with no mandatory JavaScript.
+email:
+- NICE-DEV226@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/rendry.rb
+- lib/rendry/version.rb
+homepage: https://github.com/NICE-DEV226/rendry-ui
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/NICE-DEV226/rendry-ui
+  source_code_uri: https://github.com/NICE-DEV226/rendry-ui
+  changelog_uri: https://github.com/NICE-DEV226/rendry-ui/releases
+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.6.9
+specification_version: 4
+summary: Lightweight server-rendered HTML DSL for Ruby
+test_files: []