joys 0.1.0 → 0.1.2

data/lib/joys/core.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+# 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
+  end
+  def self.reset!
+  @cache.clear
+  @templates.clear
+  @compiled_styles.clear
+  @consolidated_cache.clear
+  @layouts.clear
+  @current_component = nil
+  @current_page = nil
+end
+
+  def self.cache(cache_id, *args, &block);cache_key = [cache_id, args.hash];@cache[cache_key] ||= block.call;end
+  def self.define(type, name, &template)
+    full_name = "#{type}_#{name}";@templates[full_name] = template
+    case type
+    when :layout
+      @layouts[name] = Joys::Render.layout(&template)
+      define_singleton_method(full_name) { @layouts[name] }
+    when :page
+      define_singleton_method(full_name) do |**locals|
+        old_component = @current_component
+        old_page = @current_page
+        @current_page = full_name
+        @current_component = nil
+        result = cache(full_name, locals.hash) do
+          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
+            @current_page = full_name    # Pass page context to renderer
+          end
+          renderer.instance_exec(&template)
+          renderer.instance_variable_get(:@bf)
+        end
+        @current_component = old_component
+        @current_page = old_page
+        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
+          Joys::Render.compile { instance_exec(*args, &template) }
+        end
+        @current_component = old_component
+        result
+      end
+    end
+  end
+  def self.clear_cache!
+    @cache.clear
+    @compiled_styles.clear
+    @consolidated_cache.clear
+  end
+  def self.page(name, **locals)
+    page_name = "page_#{name}"
+    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
+      @current_page = page_name
+      @used_components.add(page_name) if Joys.compiled_styles[page_name]
+    end
+    page_template = @templates[page_name]
+    raise "No page template defined for #{name}" unless page_template
+    old_page = @current_page
+    @current_page = page_name
+    renderer.instance_exec(&page_template)
+    @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
+  
+  comp_template = @templates["comp_#{name}"]
+  raise "No comp template defined for #{name}" unless comp_template
+  
+  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)
+  
+  @current_component = old_component
+  renderer.instance_variable_get(:@bf).freeze
+end
+  def self.html(&block)
+    renderer = Object.new
+    renderer.extend(Render::Helpers)
+    renderer.extend(Tags)
+    renderer.instance_variable_set(:@bf, String.new)
+    
+    # Only inherit page context for style compilation
+    renderer.instance_variable_set(:@current_page, current_page) if current_page
+    
+    renderer.instance_eval(&block)
+    renderer.instance_variable_get(:@bf)
+  end
+  module Render
+    def self.compile(&block)
+      context = Object.new;context.extend(Helpers);context.extend(Tags)
+      context.instance_eval { @bf = String.new(capacity: 8192);@slots={};@used_components = Set.new}
+      context.instance_eval(&block)
+      context.instance_variable_get(:@bf).freeze
+    end
+    def self.layout(&layout_block)
+      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.instance_eval(&layout_block)
+      precompiled = template.instance_variable_get(:@bf).freeze
+      ->(context, &content_block) {
+        context.instance_eval(&content_block) if content_block
+        slots = context.instance_variable_get(:@slots) || {}
+        used_components = context.instance_variable_get(:@used_components)
+        if used_components && !used_components.empty?
+          auto_styles = Joys::Styles.render_consolidated_styles(used_components)
+        else
+          auto_styles = ""
+        end
+        slot_regex = /<!--SLOT:(.*?)-->/.freeze
+        result = precompiled.gsub(slot_regex) do |match|
+          slot_name = $1.to_sym
+          slots[slot_name] || ""
+        end
+        if result.include?('<!--STYLES-->')
+          result = result.gsub(/<!--STYLES-->/, auto_styles)
+        end
+        if result.include?('<!--EXTERNAL_STYLES-->')
+          external_styles = Joys::Styles.render_external_styles(used_components)
+          result = result.gsub(/<!--EXTERNAL_STYLES-->/, external_styles)
+        end
+        result
+      }
+    end
+  end
+end

data/lib/joys/helpers.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+# lib/joys/helpers.rb
+module Joys
+  module Render
+    module Helpers
+      def txt(content); @bf << CGI.escapeHTML(content.to_s); nil; end
+      def raw(content); @bf << content.to_s; nil; end
+      def push(name, &block)
+        old_buffer = @bf;@slots ||= {}
+        @bf = String.new;instance_eval(&block)
+        content = @bf;@slots[name] = content
+        @bf = old_buffer;nil
+      end
+      def pull(name = :main)
+        @slots ||= {};@bf << @slots[name].to_s if @slots[name];nil
+      end
+      def pull_styles;@bf << "<!--STYLES-->";nil;end
+      def pull_external_styles;@bf << "<!--EXTERNAL_STYLES-->";nil;end
+
+def comp(name, *args, **kwargs, &block)
+  comp_name = "comp_#{name}"
+  @used_components ||= Set.new
+  @used_components.add(comp_name)
+  raw Joys.send(comp_name, *args, **kwargs, &block)
+end
+      def layout(name, &block)
+        layout_lambda = Joys.layouts[name]
+        raise ArgumentError, "Layout `#{name}` not registered" unless layout_lambda
+        raw layout_lambda.call(self, &block)
+      end
+      def styles(scoped: false, &block)
+        context_name = Joys.current_component
+        context_name ||= Joys.current_page
+        context_name ||= @current_page
+        return nil unless context_name
+        return nil if Joys.compiled_styles[context_name]
+        @style_base_css = []
+        @style_media_queries = {}
+        @style_scoped = scoped
+        instance_eval(&block)
+        Joys::Styles.compile_component_styles(
+          context_name,
+          @style_base_css,
+          @style_media_queries,
+          @style_scoped
+        )
+        if context_name&.start_with?('page_')
+          @used_components ||= Set.new
+          @used_components.add(context_name)
+        end
+        @style_base_css = @style_media_queries = @style_scoped = nil;nil
+      end
+      def doctype;raw  "<!doctype html>";end
+      def css(content);@style_base_css&.push(content);nil;end
+      def media_max(breakpoint, content)
+        return nil unless @style_media_queries
+        key = "m-max-#{breakpoint}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+      def media_min(breakpoint, content)
+        return nil unless @style_media_queries  
+        key = "m-min-#{breakpoint}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+      def media_minmax(min_bp, max_bp, content)
+        return nil unless @style_media_queries
+        key = "m-minmax-#{min_bp}-#{max_bp}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+      def container_min(size, content)
+        return nil unless @style_media_queries
+        key = "c-min-#{size}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+      def container_max(size, content)
+        return nil unless @style_media_queries
+        key = "c-max-#{size}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+      def container_minmax(min_size, max_size, content)
+        return nil unless @style_media_queries
+        key = "c-minmax-#{min_size}-#{max_size}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+      def named_container_min(name, size, content)
+        return nil unless @style_media_queries
+        key = "c-#{name}-min-#{size}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+      def named_container_max(name, size, content)
+        return nil unless @style_media_queries
+        key = "c-#{name}-max-#{size}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+      def named_container_minmax(name, min_size, max_size, content)
+        return nil unless @style_media_queries
+        key = "c-#{name}-minmax-#{min_size}-#{max_size}"
+        @style_media_queries[key] ||= []
+        @style_media_queries[key] << content;nil
+      end
+    end
+  end
+end

data/lib/joys/styles.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+# lib/joys/styles.rb - Simplified Component Styling
+require 'fileutils'
+require 'set'
+module Joys
+  module Styles
+    def self.compile_component_styles(comp_name, base_css, media_queries, scoped)
+      scope_prefix = scoped ? ".#{comp_name.tr('_', '-')} " : ""
+      processed_base_css = base_css.map { |css| scope_css(css, scope_prefix) }
+      processed_media_queries = {}
+      
+      # FIX: Actually iterate over the media_queries parameter
+      media_queries.each do |key, css_rules|
+        scoped_rules = css_rules.map { |css| scope_css(css, scope_prefix) }
+        processed_media_queries[key] = scoped_rules
+      end
+      
+      Joys.compiled_styles[comp_name] = {
+        base_css: processed_base_css,
+        media_queries: processed_media_queries,
+        container_queries: {} # Keep this for compatibility, but media_queries contains all now
+      }.freeze
+    end
+    
+    private
+    
+    def self.render_consolidated_styles(used_components)
+      return "" if used_components.empty?
+      cache_key = used_components.to_a.sort.join(',')
+      return Joys.consolidated_cache[cache_key] if Joys.consolidated_cache.key?(cache_key)
+      buffer = String.new(capacity: 4096)
+      min_queries = Hash.new { |h,k| h[k] = [] }
+      max_queries = Hash.new { |h,k| h[k] = [] }
+      minmax_queries = []
+      container_min_queries = Hash.new { |h,k| h[k] = [] }
+      container_max_queries = Hash.new { |h,k| h[k] = [] }
+      container_minmax_queries = []
+      container_named_queries = Hash.new { |h,k| h[k] = {min: Hash.new { |h,k| h[k] = [] }, max: Hash.new { |h,k| h[k] = [] }, minmax: []} }
+      seen_base = Set.new
+      
+      used_components.each do |comp|
+        styles = Joys.compiled_styles[comp] || next
+        styles[:base_css].each do |rule|
+          next if seen_base.include?(rule)
+          buffer << rule
+          seen_base << rule
+        end
+        styles[:media_queries].each do |key, rules|
+          case key
+          # FIX: Updated regex patterns to match the actual key formats
+          when /^m-min-(\d+)$/
+            min_queries[$1.to_i].concat(rules)
+          when /^m-max-(\d+)$/
+            max_queries[$1.to_i].concat(rules)
+          when /^m-minmax-(\d+)-(\d+)$/
+            minmax_queries << { min: $1.to_i, max: $2.to_i, css: rules }
+          when /^c-min-(\d+)$/
+            container_min_queries[$1.to_i].concat(rules)
+          when /^c-max-(\d+)$/
+            container_max_queries[$1.to_i].concat(rules)
+          when /^c-minmax-(\d+)-(\d+)$/
+            container_minmax_queries << { min: $1.to_i, max: $2.to_i, css: rules }
+          when /^c-([^-]+)-min-(\d+)$/
+            name, size = $1, $2.to_i
+            container_named_queries[name][:min][size].concat(rules)
+          when /^c-([^-]+)-max-(\d+)$/
+            name, size = $1, $2.to_i
+            container_named_queries[name][:max][size].concat(rules)
+          when /^c-([^-]+)-minmax-(\d+)-(\d+)$/
+            name, min_size, max_size = $1, $2.to_i, $3.to_i
+            container_named_queries[name][:minmax] << { min: min_size, max: max_size, css: rules }
+          end
+        end
+      end
+      
+      max_queries.sort.reverse.each do |bp, rules|
+        buffer << "@media (max-width: #{bp}px){"
+        rules.uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      min_queries.sort.each do |bp, rules|
+        buffer << "@media (min-width: #{bp}px){"
+        rules.uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      minmax_queries.sort_by { |q| [q[:min], q[:max]] }.each do |q|
+        buffer << "@media (min-width: #{q[:min]}px) and (max-width: #{q[:max]}px){"
+        q[:css].uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      container_max_queries.sort.reverse.each do |size, rules|
+        buffer << "@container (max-width: #{size}px){"
+        rules.uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      container_min_queries.sort.each do |size, rules|
+        buffer << "@container (min-width: #{size}px){"
+        rules.uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      container_minmax_queries.sort_by { |q| [q[:min], q[:max]] }.each do |q|
+        buffer << "@container (min-width: #{q[:min]}px) and (max-width: #{q[:max]}px){"
+        q[:css].uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      container_named_queries.each do |name, queries|
+        queries[:max].sort.reverse.each do |size, rules|
+          buffer << "@container #{name} (max-width: #{size}px){"
+          rules.uniq.each { |r| buffer << r }
+          buffer << "}"
+        end
+        queries[:min].sort.each do |size, rules|
+          buffer << "@container #{name} (min-width: #{size}px){"
+          rules.uniq.each { |r| buffer << r }
+          buffer << "}"
+        end
+        queries[:minmax].sort_by { |q| [q[:min], q[:max]] }.each do |q|
+          buffer << "@container #{name} (min-width: #{q[:min]}px) and (max-width: #{q[:max]}px){"
+          q[:css].uniq.each { |r| buffer << r }
+          buffer << "}"
+        end
+      end
+      buffer.freeze.tap { |css| Joys.consolidated_cache[cache_key] = css }
+    end
+    
+    def self.render_external_styles(used_components)
+      return "" if used_components.empty?
+      cache_key = used_components.to_a.sort.join(',')
+      css_filename = "#{cache_key}.css"
+      #css_filename = "#{Digest::SHA256.hexdigest(cache_key)[0..12]}.css"
+      css_path = Joys.css_path || "public/css"
+      full_path = File.join(css_path, css_filename)
+      FileUtils.mkdir_p(css_path)
+      unless File.exist?(full_path)
+        css_content = render_consolidated_styles(used_components)
+        File.write(full_path, css_content)
+      end
+      "<link rel=\"stylesheet\" href=\"/css/#{css_filename}\">"
+    end
+    
+    def self.scope_css(css, scope_prefix)
+      return css if scope_prefix.empty?
+      selectors = css.split(',')
+      scoped_selectors = selectors.map do |selector|
+        selector.strip!
+        if match = selector.match(/^\s*\.([a-zA-Z][\w-]*)/)
+        #if selector.match(/^\s*\.([a-zA-Z][\w-]*)/)
+          "#{scope_prefix}#{selector}"
+        else
+          selector
+        end
+      end
+      scoped_selectors.join(', ')
+    end
+  end
+end

data/lib/joys/tags.rb

@@ -0,0 +1,120 @@
+# lib/joys/tags.rb
+module Joys
+  module Tags
+    VOID_TAGS = %w[area base br col embed hr img input link meta param source track wbr].freeze
+    TAGS = %w[
+      a abbr address article aside audio b bdi bdo blockquote body button canvas
+      caption cite code colgroup data datalist dd del details dfn dialog div dl dt
+      em fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup
+      html i iframe ins kbd label legend li main map mark menu meter nav noscript
+      object ol optgroup option output p picture pre progress q rp rt ruby s samp
+      script section select small span strong style sub summary sup table tbody td
+      template textarea tfoot th thead time title tr u ul var video
+    ].freeze
+    BOOLEAN_ATTRS = %w[
+      disabled readonly read_only multiple checked selected 
+      auto_focus autofocus no_validate novalidate form_novalidate formnovalidate
+      hidden required open reversed scoped seamless muted auto_play autoplay 
+      controls loop default inert item_scope itemscope
+    ].to_set.freeze
+    
+    CLS = ' class="'.freeze
+    QUO = '"'.freeze
+    BC = '>'.freeze
+    BO = '<'.freeze
+    GTS = '</'.freeze
+    EQ = '="'.freeze
+    
+    VOID_TAGS.each do |tag|
+      define_method(tag) do |cs: nil, **attrs|
+        class_string = case cs
+        when String, Symbol then cs.to_s
+        when Array then cs.compact.reject { |c| c == false }.map(&:to_s).join(" ")
+        else ""
+        end
+        
+        @bf << BO << tag
+        @bf << CLS << class_string << QUO unless class_string.empty?
+        
+        attrs.each do |k, v|
+          key = k.to_s
+          
+          if v.is_a?(Hash) && (key == "data" || key.start_with?("aria"))
+            prefix = key.tr('_', '-')
+            v.each do |sk, sv|
+              next if sv.nil? || sv == false  # Skip nil and boolean false
+              attr_name = "#{prefix}-#{sk.to_s.tr('_', '-')}"
+              @bf << " #{attr_name}#{EQ}#{CGI.escapeHTML(sv.to_s)}#{QUO}"
+            end
+          else
+            next if v.nil?
+            
+            if BOOLEAN_ATTRS.include?(key)
+              @bf << " #{key.tr('_', '')}" if v
+            elsif v == false
+              next
+            else
+              attr_name = key.tr('_', '-')
+              @bf << " #{attr_name}#{EQ}#{CGI.escapeHTML(v.to_s)}#{QUO}"
+            end
+          end
+        end
+        
+        @bf << BC
+        nil
+      end
+    end
+    
+    TAGS.each do |tag|
+      define_method(tag) do |content = nil, cs: nil, raw: false, **attrs, &block|
+        class_string = case cs
+        when String, Symbol then cs.to_s
+        when Array then cs.compact.reject { |c| c == false }.map(&:to_s).join(" ")
+        else ""
+        end
+        
+        @bf << BO << tag
+        @bf << CLS << class_string << QUO unless class_string.empty?
+        
+        attrs.each do |k, v|
+          key = k.to_s
+          
+          if v.is_a?(Hash) && (key == "data" || key.start_with?("aria"))
+            prefix = key.tr('_', '-')
+            v.each do |sk, sv|
+              next if sv.nil? || sv == false  # Skip nil and boolean false
+              attr_name = "#{prefix}-#{sk.to_s.tr('_', '-')}"
+              @bf << " #{attr_name}#{EQ}#{CGI.escapeHTML(sv.to_s)}#{QUO}"
+            end
+          else
+            next if v.nil?
+            
+            if BOOLEAN_ATTRS.include?(key)
+              @bf << " #{key.tr('_', '')}" if v
+            elsif v == false
+              next
+            else
+              attr_name = key.tr('_', '-')
+              @bf << " #{attr_name}#{EQ}#{CGI.escapeHTML(v.to_s)}#{QUO}"
+            end
+          end
+        end
+        
+        @bf << BC
+        
+        if block
+          instance_eval(&block)
+        elsif content
+          @bf << (raw ? content.to_s : CGI.escapeHTML(content.to_s))
+        end
+        
+        @bf << GTS << tag << BC
+        nil
+      end
+      
+      define_method("#{tag}!") do |content = nil, cs: nil, **attrs, &block|
+        send(tag, content, cs: cs, raw: true, **attrs, &block)
+      end
+    end
+  end
+end

data/lib/joys/version.rb

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

data/lib/joys.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "joys/version"
-
-module Joys
-  class Error < StandardError; end
-  # Your code goes here...
-end
+require_relative "joys/core"
+require_relative "joys/helpers"
+require_relative "joys/styles"
+require_relative "joys/tags"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: joys
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Steven Garcia
@@ -25,8 +25,14 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- joys-0.1.0.gem
+- joys-0.1.1.gem
 - lib/.DS_Store
 - lib/joys.rb
+- lib/joys/core.rb
+- lib/joys/helpers.rb
+- lib/joys/styles.rb
+- lib/joys/tags.rb
 - lib/joys/version.rb
 - sig/joys.rbs
 homepage: https://github.com/activestylus/joys.git