joys 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6927c0ba1da72024357dea7dd031f82c7feb252f079b4835ab98c8554f035f06
-  data.tar.gz: 0ece16f17983a990d18553873f31e521b23790e00a83c6f572c0ebe86cede617
+  metadata.gz: 97eaf65fc04c1055382709a285445f71304e942fc1178e15f12d9a4184b72453
+  data.tar.gz: 8c4e0c0a46516a48be09554d2774164e9f2fc1ca662f2e708896b8cd743dffc3
 SHA512:
-  metadata.gz: d194c2dd9a7a1ba5d3045efde26b8ff03ed74482256b4157b0bd646ebae50b5ed4eb8736b7491d485fd175a7e1eafd4b9f15c08f20ed7bedb08d45db013ffc0d
-  data.tar.gz: a830066addb6ced9156c3549464be742b1aaa60df5ec6a279f33e7db1e3125c1b8ed5828b42e132904ea2b573ac0236e1de0f63fc1c2f890282966803fbe6feb
+  metadata.gz: 88b135651e912e1b6f2402599372d5c6615873805de142e5a0e4ebfb88ad23862fa3203bb72c1a90417fbf45cb14b3061e89d13bac015206bc7a4e688c398d33
+  data.tar.gz: 50882f67ffe2de1da38f7dc3d83462f0eaf0ef6e3ab1149bc73ded3a713104ed078f1c048cea123c1048da8cf77a90a532335b805de6a89652d168ac55c30297

data/CHANGELOG.md

@@ -28,4 +28,14 @@
 
 ## [0.1.5] - 2025-09-30
 
-- Improved Rails integration and helper availability
+- Improved Rails integration and helper availability
+
+## [0.1.6] - 2025-10-02
+
+- Joy.define(:comp) now captures block arguments
+
+
+## [0.1.7] - 2026-01-09
+
+- Added get() for pulling strings outside the buffer within layouts:
+  `body(cs:get(:bodyclass)) {...}`

data/README.md

@@ -1,3 +1,5 @@
+![joys](https://github.com/user-attachments/assets/ec594256-b1ee-4ec7-a876-491abcfa1d66)
+
 # Joys - HTML Templates at the Speed of Light
 
 **Write HTML like Ruby, render it at the speed of C.**
@@ -9,7 +11,7 @@ Joys is a pure-Ruby HTML templating engine with built-in CSS and ludicrous-speed
 - **Blazing Fast** - 3x faster on cold render. Orders of magnitude faster after caching.
 - **Pure Ruby** - No new syntax to learn. It's just methods and blocks.
 - **Testable** - Components are just functions. Test them like any Ruby code.
-- **Fully Integrated Styling** - Deduplicated, sorted css right inside your components
+- **Fully Integrated Styling** - Deduplicated, responsive css right inside your components
 - **Framework Agnostic** - Use it in Rails, Roda, Sinatra, Hanami, Syro, etc.
 
 ---
@@ -286,110 +288,6 @@ Joys.define(:comp, :pricing_card) do |plan|
   }
 end
 ```
----
-## A Word on Performance
-
-Using simple components and views (only 3 layers of nesting) we can see how Joy stacks up:
-
-### Simple Templates (385 chars)
-
-#### ❄️ COLD RENDER (new object per call)
-|      | user   | system  | total | real.  |
-|------|--------|--------|--------|--------|
-|Joys: |0.060535|0.000200|0.060735|0.060736|
-|Slim: |0.048344|0.000183|0.048527|0.048530|
-|ERB:  |0.301811|0.000808|0.302619|0.302625|
-|Phlex:|0.069636|0.000470|0.070106|0.071157|
-
-#### 🔥 HOT RENDER (cached objects)
-|      | user   | system  | total  | real   |
-|------|--------|---------|--------|--------|
-|Joys: |0.065255| 0.000257|0.065512|0.065512|
-|Slim: |0.049323| 0.000295|0.049618|0.049695|
-|ERB:  |0.309757| 0.001167|0.310924|0.310929|
-|Phlex:|0.069663| 0.000141|0.069804|0.069805|
-
-#### 💾 MEMORY USAGE
-Joys memory: 532356 bytes
-Slim memory: 40503436 bytes
-Phlex memory: 8000 bytes
-ERB memory: 1669256 bytes
-
-At smaller scales performance is on par with Phlex, which has excellent speed and superior
-
-### Complex Templates (8,000+ chars)
-
-As template complexity grows, Joys starts to really show off its optimizations. This benchmark tests a full dashboard page with 5 components and 2 loops yields:
-
-* Data parsing
-* Layouts
-* Multiple Content Slots
-* Multiple Components
-* Several Iterations
-* Conditions
-
-### ❄️ COLD RENDER (new object per call)
-
-This is the bare bones benchmark, no "cheating" allowed.
-
-|      | user   | system | total  | real   |
-|------|--------|--------|--------|--------|
-| Joys |0.051715|0.000364|0.052079|0.052080|
-| ERB  |0.520495|0.003696|0.524191|0.524187|
-| Slim |6.001650|0.019418|6.021068|6.021013|
-| Phlex|0.169567|0.000373|0.169940|0.169938|
-
-Note: Joys achieves its 'cold render' speed by eliminating object overhead and using simple string operations with smart memory management.
-
-### 🔥 HOT RENDER (cached objects)
-
-|      | user    | system | total   | real   |
-|------|---------|--------|---------|--------|
-|JOYS: | 0.000463|0.000010| 0.000473|0.000473|
-|SLIM: | 0.045881|0.000358| 0.046239|0.046243|
-|PHLEX:| 0.167631|0.000760| 0.168391|0.168661|
-|ERB:  | 0.394509|0.004084| 0.398593|0.398614|
-
-Note: Joys achieves its 'hot render' speed by compiling a template's structure into a highly optimized render function the first time it's called. Subsequent calls with the same component structure reuse this function, bypassing compilation and object allocation, and only interpolating the dynamic data.
-
-
-### 💾 MEMORY USAGE
-
-Joys memory: 7587400 bytes
-Slim memory: 217778600 bytes
-Phlex memory: 9956000 bytes
-ERB memory: 7264240 bytes
-
-Even without caching, Joys is rendering at around 50 milliseconds.
-
-The real performance comes after caching at half a millisecond.
-
-That's not just fast, its _ludicrous speed_ 🚀 All thanks to Joys's one-time compilation and caching of the template structure.
-
-But don't take our word for it:
-
-```
-gem install erb slim phlex joys
-
-# Simple benchmark
-ruby text/bench/simple.rb
-
-# Complex benchmark
-ruby text/bench/deep.rb
-```
-
-Note: If you have any additions, critiques or input on these benchmarks please submit a pull request.
-
-### Performance Philosophy
-
-Joys attains its incredible speed through:
-
-1. **Precompiled layouts** - Templates compile once, render many
-2. **Direct string building** - No intermediate AST or object allocation
-3. **Smart caching** - Components cache by arguments automatically
-4. **Zero abstraction penalty** - It's just method calls and string concatenation
-
-All achieved without C or Rust. Just plain old Ruby, with a core of under 500 lines of code. 
 
 ---
 
@@ -1117,6 +1015,113 @@ The `?` suffix provides a clean, consistent way to integrate markup processing i
 
 ---
 
+---
+## A Word on Performance
+
+Using simple components and views (only 3 layers of nesting) we can see how Joy stacks up:
+
+### Simple Templates (385 chars)
+
+#### ❄️ COLD RENDER (new object per call)
+|      | user   | system  | total | real.  |
+|------|--------|--------|--------|--------|
+|Joys: |0.060535|0.000200|0.060735|0.060736|
+|Slim: |0.048344|0.000183|0.048527|0.048530|
+|ERB:  |0.301811|0.000808|0.302619|0.302625|
+|Phlex:|0.069636|0.000470|0.070106|0.071157|
+
+#### 🔥 HOT RENDER (cached objects)
+|      | user   | system  | total  | real   |
+|------|--------|---------|--------|--------|
+|Joys: |0.065255| 0.000257|0.065512|0.065512|
+|Slim: |0.049323| 0.000295|0.049618|0.049695|
+|ERB:  |0.309757| 0.001167|0.310924|0.310929|
+|Phlex:|0.069663| 0.000141|0.069804|0.069805|
+
+#### 💾 MEMORY USAGE
+Joys memory: 532356 bytes
+Slim memory: 40503436 bytes
+Phlex memory: 8000 bytes
+ERB memory: 1669256 bytes
+
+At smaller scales performance is on par with Phlex, which has excellent speed and superior
+
+### Complex Templates (8,000+ chars)
+
+As template complexity grows, Joys starts to really show off its optimizations. This benchmark tests a full dashboard page with 5 components and 2 loops yields:
+
+* Data parsing
+* Layouts
+* Multiple Content Slots
+* Multiple Components
+* Several Iterations
+* Conditions
+
+### ❄️ COLD RENDER (new object per call)
+
+This is the bare bones benchmark, no "cheating" allowed.
+
+|      | user   | system | total  | real   |
+|------|--------|--------|--------|--------|
+| Joys |0.051715|0.000364|0.052079|0.052080|
+| ERB  |0.520495|0.003696|0.524191|0.524187|
+| Slim |6.001650|0.019418|6.021068|6.021013|
+| Phlex|0.169567|0.000373|0.169940|0.169938|
+
+Note: Joys achieves its 'cold render' speed by eliminating object overhead and using simple string operations with smart memory management.
+
+### 🔥 HOT RENDER (cached objects)
+
+|      | user    | system | total   | real   |
+|------|---------|--------|---------|--------|
+|JOYS: | 0.000463|0.000010| 0.000473|0.000473|
+|SLIM: | 0.045881|0.000358| 0.046239|0.046243|
+|PHLEX:| 0.167631|0.000760| 0.168391|0.168661|
+|ERB:  | 0.394509|0.004084| 0.398593|0.398614|
+
+Note: Joys achieves its 'hot render' speed by compiling a template's structure into a highly optimized render function the first time it's called. Subsequent calls with the same component structure reuse this function, bypassing compilation and object allocation, and only interpolating the dynamic data.
+
+
+### 💾 MEMORY USAGE
+
+Joys memory: 7587400 bytes
+Slim memory: 217778600 bytes
+Phlex memory: 9956000 bytes
+ERB memory: 7264240 bytes
+
+Even without caching, Joys is rendering at around 50 milliseconds.
+
+The real performance comes after caching at half a millisecond.
+
+That's not just fast, its _ludicrous speed_ 🚀 All thanks to Joys's one-time compilation and caching of the template structure.
+
+But don't take our word for it:
+
+```
+gem install erb slim phlex joys
+
+# Simple benchmark
+ruby text/bench/simple.rb
+
+# Complex benchmark
+ruby text/bench/deep.rb
+```
+
+Note: If you have any additions, critiques or input on these benchmarks please submit a pull request.
+
+### Performance Philosophy
+
+Joys attains its incredible speed through:
+
+1. **Precompiled layouts** - Templates compile once, render many
+2. **Direct string building** - No intermediate AST or object allocation
+3. **Smart caching** - Components cache by arguments automatically
+4. **Zero abstraction penalty** - It's just method calls and string concatenation
+
+All achieved without C or Rust. Just plain old Ruby, with a core of under 500 lines of code. 
+
+---
+
 ## The Final Assessment: When to Use Joys
 
 - You want **high-throughput** Ruby APIs serving HTML.
@@ -1182,4 +1187,4 @@ Joys isn’t just a templating engine. It’s a new definition of what rendering
 
 ## Thanks and Gratitude
 
-Massive shout-out to the Masatoshi Seki (ERB), Daniel Mendler (Slim), Daniel Mendler (Phlex/P2), and Jonathan Gillette (Markaby). All of you have made countless lives so much easier. The ruby community thanks you for your service!
+Massive shout-out to the Masatoshi Seki (ERB), Daniel Mendler (Slim), Daniel Mendler (Phlex/P2), and Jonathan Gillette (Markaby). All of you have made countless lives so much easier. The ruby community thanks you for your service!

data/lib/joys/config.rb

@@ -63,17 +63,13 @@ module Joys
         }
       end
       module ControllerMethods
-        def render_joy(path, **locals)
-          Joys.reload! if Config.dev?
-          file = File.join(Config.pages, "#{path}.rb")
-          raise "Template not found: #{file}" unless File.exist?(file)
-          
-          renderer = Object.new
-          renderer.extend(Render::Helpers)
-          locals.each { |k, v| renderer.instance_variable_set(:"@#{k}", v) }
-          
-          result = renderer.instance_eval(File.read(file), file)
-          result.is_a?(String) ? result.freeze : ""
+        def render_joy(path,**locals)
+          context=Joys.adapter.controller_context(self)
+          context.each{|k,v|Thread.current[k]=v}
+          result=Joys.render_joy(path,**locals)
+          render html:result.html_safe,layout:false
+        ensure
+          context&.keys&.each{|k|Thread.current[k]=nil}
         end
       end
     end
@@ -92,14 +88,20 @@ module Joys
   end
   class << self
     attr_accessor :adapter,:css_registry
-    def render_joy(path,**locals)
-      Joys.reload! if Config.dev?
-      file=File.join(Config.pages,"#{path}.rb")
-      raise "Template not found: #{file}" unless File.exist?(file)
-      locals.each{|k,v|eval("@#{k}=v",binding)}
-      result=eval(File.read(file),binding,file)
-      result.is_a?(String) ? result.freeze : ""
-    end
+def render_joy(path, **locals)
+  Joys.reload! if Config.dev?
+  file = File.join(Config.pages, "#{path}.rb")
+  raise "Template not found: #{file}" unless File.exist?(file)
+  
+  locals.each { |k, v| eval("@#{k} = v", binding) }
+  
+  # Extend the current binding with helpers
+  helper_binding = binding
+  helper_binding.eval("extend Joys::Render::Helpers")
+  
+  result = eval(File.read(file), helper_binding, file)
+  result.is_a?(String) ? result.freeze : ""
+end
     def preload!;load_helpers;load_dir(Config.layouts);load_dir(Config.components);load_css_parts;end
     def load_helpers
       return unless Dir.exist?(Config.helpers)
@@ -129,6 +131,7 @@ module Joys
       end
       @adapter&.integrate!
     end
+    
     def reload!;clear_cache!;@css_registry={};preload!;end
     def load_dir(dir);Dir.exist?(dir)&&Dir.glob("#{dir}/**/*.rb").each{|f|load f};end
   end

data/lib/joys/core.rb

@@ -2,16 +2,10 @@
 # lib/joys/core.rb
 module Joys
   @css_path = "public/css";@cache={};@templates={};@compiled_styles={};@consolidated_cache={};@current_component = nil;@layouts={}
+  
   class << self
     attr_reader :cache, :templates, :compiled_styles, :consolidated_cache, :layouts
     attr_accessor :current_component, :current_page, :css_path,:adapter,:css_registry
-    # def load_css_parts
-    #   return unless Dir.exist?(Config.css_parts)
-    #   Dir.glob("#{Config.css_parts}/**/*.css").each do |f|
-    #     relative_path = f.sub("#{Config.css_parts}/", '').sub('.css', '')
-    #     @css_registry[relative_path] = File.read(f).gsub(/\r?\n/, "")
-    #   end
-    # end
   end
   def self.make(name, *args, **kwargs, &block)
     Joys.define :comp, name, *args, **kwargs, &block
@@ -57,17 +51,31 @@ module Joys
         result.freeze
       end
     else
-      define_singleton_method(full_name) do |*args|
-        old_component = @current_component
-        @current_component = full_name if type == :comp
-        result = cache(full_name, *args) do
-          # This call now returns a hash, and the hash will be cached.
-          Joys::Render.compile(full_name) { instance_exec(*args, &template) }
-        end
-        @current_component = old_component
-        result
+  define_singleton_method(full_name) do |*args, **kwargs, &block|  # ADD &block here
+    old_component = @current_component
+    @current_component = full_name
+    result = cache(full_name, *args, kwargs.hash, block.object_id) do  # Include block in cache key
+      # Capture block content if provided
+      content = nil
+      if block
+        capture_renderer = Object.new
+        capture_renderer.extend(Render::Helpers)
+        capture_renderer.extend(Tags)
+        capture_renderer.instance_eval { @bf = String.new(capacity: 8192) }
+        capture_renderer.instance_exec(&block)
+        content = capture_renderer.instance_variable_get(:@bf)
+      end
+      
+      # Compile with content available
+      Joys::Render.compile(full_name) do
+        @content = content
+        instance_exec(*args, **kwargs, &template)
       end
     end
+    @current_component = old_component
+    result
+  end
+    end
   end
   def self.clear_cache!
     @cache.clear
@@ -95,29 +103,70 @@ module Joys
     @current_page = old_page
     renderer.instance_variable_get(:@bf).freeze
   end
-  def self.comp(name, *args, **locals, &block)
-    renderer = Object.new
-    renderer.extend(Render::Helpers)
-    renderer.extend(Tags)
-    locals.each { |k, v| renderer.instance_variable_set("@#{k}", v) }
-    renderer.instance_eval do
-      @bf = String.new(capacity: 8192)
-      @slots = {}
-      @used_components = Set.new
-    end
+def self.comp(name, *args, **locals, &block)
+  renderer = Object.new
+  renderer.extend(Render::Helpers)
+  renderer.extend(Tags)
+  locals.each { |k, v| renderer.instance_variable_set("@#{k}", v) }
+  
+  # ADD THIS: Set args as instance variables
+  args.each_with_index do |arg, i|
+    renderer.instance_variable_set("@arg#{i}", arg)
+  end
+  
+  renderer.instance_eval do
+    @bf = String.new(capacity: 8192)
+    @slots = {}
+    @used_components = Set.new
+  end
+  
+  comp_template = @templates["comp_#{name}"]
+  raise "No comp template defined for #{name}" unless comp_template
+  
+  old_component = @current_component
+  @current_component = "comp_#{name}"
+  
+  if block
+    capture_renderer = Object.new
+    capture_renderer.extend(Render::Helpers)
+    capture_renderer.extend(Tags)
+    capture_renderer.instance_eval { @bf = String.new(capacity: 8192) }
+    capture_renderer.instance_exec(&block)
+    renderer.instance_variable_set(:@content, capture_renderer.instance_variable_get(:@bf))
+  end
+  
+  renderer.instance_exec(*args, &comp_template)
+  
+  @current_component = old_component
+  
+  {
+    html: renderer.instance_variable_get(:@bf).freeze,
+    components: renderer.instance_variable_get(:@used_components)
+  }
+end
+  # def self.comp(name, *args, **locals, &block)
+  #   renderer = Object.new
+  #   renderer.extend(Render::Helpers)
+  #   renderer.extend(Tags)
+  #   locals.each { |k, v| renderer.instance_variable_set("@#{k}", v) }
+  #   renderer.instance_eval do
+  #     @bf = String.new(capacity: 8192)
+  #     @slots = {}
+  #     @used_components = Set.new
+  #   end
     
-    comp_template = @templates["comp_#{name}"]
-    raise "No comp template defined for #{name}" unless comp_template
+  #   comp_template = @templates["comp_#{name}"]
+  #   raise "No comp template defined for #{name}" unless comp_template
     
-    old_component = @current_component
-    @current_component = "comp_#{name}"
+  #   old_component = @current_component
+  #   @current_component = "comp_#{name}"
     
-    # Pass the block as a regular argument to the template
-    renderer.instance_exec(*args, block, &comp_template)
+  #   # Pass the block as a regular argument to the template
+  #   renderer.instance_exec(*args, block, &comp_template)
     
-    @current_component = old_component
-    renderer.instance_variable_get(:@bf).freeze
-  end
+  #   @current_component = old_component
+  #   renderer.instance_variable_get(:@bf).freeze
+  # end
 def self.html(&block)
   # Clear any previous tracking
   clear_tracked_components
@@ -159,6 +208,7 @@ end
       template = Object.new;template.extend(Helpers);template.extend(Tags)
       template.instance_eval { @bf = String.new;@slots={};@used_components = Set.new }
       template.define_singleton_method(:pull) { |name = :main| @bf << "<!--SLOT:#{name}-->"; nil }
+      template.define_singleton_method(:get) { |name| "" }
       template.instance_eval(&layout_block)
       precompiled = template.instance_variable_get(:@bf).freeze
       ->(context, &content_block) {

data/lib/joys/helpers.rb

@@ -12,6 +12,10 @@ module Joys
         content = @bf;@slots[name] = content
         @bf = old_buffer;nil
       end
+      def get(name)
+        @slots ||= {}
+        @slots[name].to_s
+      end
       def pull(name = :main)
         @slots ||= {};@bf << @slots[name].to_s if @slots[name];nil
       end

data/lib/joys/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Joys
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: joys
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Steven Garcia
@@ -29,7 +29,7 @@ files:
 - joys-0.1.2.gem
 - joys-0.1.3.gem
 - joys-0.1.4.gem
-- lib/.DS_Store
+- joys-0.1.5.gem
 - lib/joys.rb
 - lib/joys/cli.rb
 - lib/joys/config.rb