rendry 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 020307f7389d6a1dcdde28eb61c2eaf4367c9d1848584d67b7665fe45a9804a5
-  data.tar.gz: 578e5969022b18f937daa40e5fd6419937c8afb906ee0614b1500bc95820c769
+  metadata.gz: 043bde156ddb2a1af19b6c8507e676330b4ad40a079cc8850ced810396559dfa
+  data.tar.gz: bf349c54a7025081672066beb879e8ca8fa4d5e2eecf81c80c4f23f2cec85d50
 SHA512:
-  metadata.gz: e8c0cd070c058b4ea029a9ffd2c831c50ae7547ac3006f65bf282899aec0e089cf09049dcd3996c370a6ca83abc51dd19aeda17a9829755c17c2e7cd6bba9fd8
-  data.tar.gz: 9aa71174fe35e25263de312dd46ff6dc3af4a6e45ca3dbde64a6d66f61476b6d37061eccf689a96bf6d3420adb009e0bca930c63f6bc8c5e0ea09cf0ba96a899
+  metadata.gz: 8912d9c980908d713576dc50307c2ef7b9bd09a9f0be7a3072ea8507b6d491c6af0236f84a428f9adc384702195fdfb6a966322a9f5422f709462699a9ad910b
+  data.tar.gz: 1dd76f09af3eccbf79b653abcbc0c1371b27a4f281699a35157264244e637799ac1124d50dfb8343fde8866225a2401d13de16dae7c39502ddb5a87780067e6d

data/README.md

@@ -20,23 +20,38 @@ puts html
 
 Values passed to `text` and element content are escaped automatically. Use `raw` only for an HTML fragment fully controlled by your application.
 
+A block's return value is appended as content when it is a `String`, `Numeric`, or `Symbol` — so `div { task.title }` works, and strings are escaped unless they are `SafeHTML`.
+
+Helpers from the surrounding view context (e.g. Sinatra's `session`, `params`, or your own methods) are reachable inside DSL blocks and are written as escaped text:
+
+```ruby
+get "/" do
+  Rendry.render do
+    p { flash }          # calls your `flash` helper
+    session[:count]      # calls `session`
+  end
+end
+```
+
+`data:` and `aria:` attributes accept nested hashes and are flattened (`data: { toggle: "x" }` → `data-toggle="x"`). URLs with `javascript:`/`vbscript:`/non-image `data:` schemes in `href`, `src`, `action`, `formaction`, or `xlink:href` are rewritten to `#` — disable with `Rendry.sanitize_urls = false`.
+
 ## Components
 
+The lightest form is a `template` block — no `render` method needed:
+
 ```ruby
 class Badge < Rendry::Component
   def initialize(label)
     @label = label
   end
 
-  def render
-    Rendry.render { span(@label, class: "badge") }
+  template do
+    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 `{ }`.
+For full control, implement `#render` returning `Rendry.render { ... }` or a `SafeHTML`. Components also receive the view context (`view_context`) when rendered through `component`, so helpers work inside `template` blocks too.
 
 ## Features
 
@@ -120,3 +135,26 @@ The core targets four properties:
 - 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.
+
+## Contributing
+
+How about contributing to the project? I would be truly delighted to have contributors and people who are interested in the project.
+
+Rendry is deliberately small — contributions that keep it small are the most welcome:
+
+- **Bug reports and fixes** — the DSL has many edge cases (`method_missing` delegation, fragment filtering, context bridging); reproductions are gold.
+- **New built-in components** — `Rendry::Components` is a kit; adding a component is a few lines plus a CSS class in `assets/rendry.css`.
+- **Examples** — a new `examples/NN_name/` mini-project showing a real use case is the best documentation.
+- **Docs** — README sections, yard comments on public API.
+
+Please keep the zero-runtime-dependency spirit: `cgi`, `json`, and `set` are the only requires. No frontend build step, no required JS.
+
+```sh
+git clone https://github.com/NICE-DEV226/rendry-ui.git
+cd rendry-ui
+bundle install
+bundle exec rake          # run the test suite
+bundle exec rake examples # smoke-run the examples
+```
+
+Open an issue first for anything non-trivial so we can align on direction.

data/lib/rendry/version.rb

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

data/lib/rendry.rb

@@ -2,6 +2,7 @@
 
 require "cgi"
 require "json"
+require "set"
 require_relative "rendry/version"
 
 module Rendry
@@ -11,26 +12,29 @@ module Rendry
     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
+  VOID_ELEMENTS = Set.new(%w[area base br col embed hr img input link meta param source track wbr]).freeze
+  BOOLEAN_ATTRIBUTES = Set.new(%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
+      @mutex = Mutex.new
     end
 
     def fetch(key)
-      return @store[key] if @store.key?(key)
+      @mutex.synchronize do
+        return @store[key] if @store.key?(key)
 
-      value = yield
-      @store[key] = value
-      @store.shift while @store.size > @limit
-      value
+        value = yield
+        @store[key] = value
+        @store.shift while @store.size > @limit
+        value
+      end
     end
 
     def clear
-      @store.clear
+      @mutex.synchronize { @store.clear }
     end
   end
 
@@ -64,7 +68,8 @@ module Rendry
 
       if block
         children = Builder.new(enabled: @enabled)
-        Rendry.evaluate(children, &block)
+        result = Rendry.evaluate(children, &block)
+        children.append_result(result)
         content = SafeHTML.new(children.render)
       end
 
@@ -113,6 +118,9 @@ module Rendry
     end
 
     def component(component_instance, refresh: nil, &block)
+      if component_instance.respond_to?(:view_context=)
+        component_instance.view_context = @context
+      end
       if block && component_instance.respond_to?(:block=) && !component_instance.instance_variable_get(:@block)
         component_instance.block = block
       end
@@ -134,7 +142,20 @@ module Rendry
 
     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)
+        context = @context
+        helper = context && context.respond_to?(name) ? context.method(name) : nil
+        has_arguments = !(content.nil? && attributes.empty? && !block)
+        if helper && !(helper.arity == 0 && has_arguments)
+          if content.nil? && attributes.empty? && !block
+            context.public_send(name)
+          elsif content.nil?
+            context.public_send(name, **attributes, &block)
+          else
+            context.public_send(name, content, **attributes, &block)
+          end
+        else
+          tag(name.to_s.tr("_", "-"), content, **attributes, &block)
+        end
       else
         super
       end
@@ -144,6 +165,15 @@ module Rendry
       name.to_s.match?(/\A[a-z][a-z0-9_]*\z/) || super
     end
 
+    def append_result(result)
+      if result.is_a?(SafeHTML)
+        write result
+      elsif Rendry.appendable_result?(result)
+        write CGI.escapeHTML(result.to_s)
+      end
+      self
+    end
+
     private
 
     def write(string)
@@ -169,7 +199,20 @@ module Rendry
       attributes.each_with_object(+"") do |(key, value), result|
         next if value.nil? || value == false
 
+        if (key == :data || key == :aria) && value.is_a?(Hash)
+          value.each do |nested_key, nested_value|
+            next if nested_value.nil? || nested_value == false
+
+            result << %( #{key}-#{nested_key.to_s.tr('_', '-')}="#{CGI.escapeHTML(nested_value.to_s)}")
+          end
+          next
+        end
+
         attribute = key.to_s.tr("_", "-")
+        if Rendry.sanitize_urls && URL_ATTRIBUTES.include?(attribute) &&
+           value.to_s.match?(UNSAFE_URL_SCHEME)
+          value = "#"
+        end
         if BOOLEAN_ATTRIBUTES.include?(key.to_sym)
           result << " #{attribute}"
         else
@@ -181,6 +224,7 @@ module Rendry
 
   class Component
     attr_writer :block
+    attr_accessor :view_context
 
     class << self
       def refreshes(**config)
@@ -190,10 +234,21 @@ module Rendry
       def refresh_config
         @refresh_config
       end
+
+      def template(&block)
+        @template_block = block if block
+        @template_block || (superclass.template if superclass.respond_to?(:template))
+      end
     end
 
     def render
-      raise NotImplementedError, "#{self.class} must implement #render"
+      block = self.class.template
+      raise NotImplementedError, "#{self.class} must implement #render or declare a template" unless block
+
+      builder = Builder.new
+      result = Rendry.evaluate(builder, self, context: view_context, &block)
+      builder.append_result(result)
+      SafeHTML.new(builder.render)
     end
   end
 
@@ -355,8 +410,23 @@ module Rendry
     component Alert
   end
 
+  UNSAFE_URL_SCHEME = /\A\s*(javascript|vbscript|data(?!:image\/))\s*:/i
+  URL_ATTRIBUTES = %w[href src action formaction xlink:href].freeze
+
   module_function
 
+  def sanitize_urls
+    @sanitize_urls != false
+  end
+
+  def sanitize_urls=(value)
+    @sanitize_urls = value
+  end
+
+  def appendable_result?(value)
+    value.is_a?(String) || value.is_a?(Numeric) || value.is_a?(Symbol)
+  end
+
   def hx(**attributes)
     attributes.each_with_object({}) do |(key, value), result|
       value = JSON.generate(value) if value.is_a?(Hash) || value.is_a?(Array)
@@ -369,40 +439,46 @@ module Rendry
   end
 
   def current_fragments
-    @current_fragments
+    Thread.current[:rendry_current_fragments]
   end
 
   def root_builder
-    @root_builder
+    Thread.current[:rendry_root_builder]
   end
 
   def render(fragments: nil, &block)
-    filter = fragments || @current_fragments
+    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
+      previous_fragments = current_fragments
+      previous_root = root_builder
+      Thread.current[:rendry_current_fragments] = fragments.map(&:to_s)
+      Thread.current[:rendry_root_builder] = builder
       begin
-        evaluate(builder, &block)
+        result = evaluate(builder, &block)
       ensure
-        @current_fragments = previous_fragments
-        @root_builder = previous_root
+        Thread.current[:rendry_current_fragments] = previous_fragments
+        Thread.current[:rendry_root_builder] = previous_root
       end
     else
-      evaluate(builder, &block)
+      result = evaluate(builder, &block)
     end
+    builder.append_result(result)
     SafeHTML.new(builder.render)
   end
 
-  def evaluate(builder, &block)
-    owner = block.binding.receiver
+  def evaluate(builder, owner = nil, context: nil, &block)
+    owner ||= block&.binding&.receiver
+    raise ArgumentError, "Rendry.evaluate requires a block" unless block && owner
+
+    inherited = owner.instance_variable_get(:@context) if owner.is_a?(Builder)
     owner.instance_variables.each do |ivar|
-      next if ivar == :@output || ivar == :@enabled
+      next if ivar == :@output || ivar == :@enabled || ivar == :@context
 
       builder.instance_variable_set(ivar, owner.instance_variable_get(ivar))
     end
+    resolved = context || inherited || (owner unless owner.is_a?(Builder))
+    builder.instance_variable_set(:@context, resolved)
     if block.lambda? && block.arity.zero?
       builder.instance_exec(&block)
     else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rendry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - NICE-DEV226