joys 0.1.2 → 0.1.4

data/lib/joys/config.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+module Joys
+  def self.html(&block)
+    renderer = Object.new
+    renderer.extend(Render::Helpers)
+    renderer.extend(Tags)
+    renderer.instance_variable_set(:@bf, String.new)
+    renderer.instance_variable_set(:@current_page, "page_standalone")
+    renderer.instance_variable_set(:@used_components, Set.new)
+    renderer.instance_variable_set(:@slots, {})
+    renderer.instance_eval(&block)
+    renderer.instance_variable_get(:@bf)
+  end
+  module Config
+    class << self
+      attr_accessor :env,:pages,:layouts,:components,:css_parts,:helpers,:markup_parser
+      def markup_parser
+        @markup_parser ||= ->(content) { content.to_s }
+      end
+      def env;@env||=ENV['JOYS_ENV']||(defined?(::Rails) ? ::Rails.env.to_s : "development");end
+      def dev?;env!="production";end
+      def pages;@pages||=path("pages");end
+      def layouts;@layouts||=path("layouts");end  
+      def components;@components||=path("components");end
+      def css_parts;@css_parts||=path("css");end
+      def helpers;@helpers||=path("helpers");end
+      private
+      def path(t);defined?(::Rails) ? ::Rails.root.join("app/views/joys/#{t}").to_s : "views/joys/#{t}";end
+    end
+  end
+  module Adapters
+    class Base
+      def integrate!;raise NotImplementedError;end
+      def inject_helpers!;raise NotImplementedError;end
+      def controller_context(controller);{};end
+    end
+    class Rails < Base
+      def integrate!
+        return unless defined?(ActionController::Base)
+        ActionController::Base.include(ControllerMethods)
+        inject_helpers!
+        ::Rails.application.config.to_prepare do
+          Joys.preload! if ::Rails.env.production?
+          Joys::Render::Helpers.include(::Rails.application.helpers)
+        end
+      end
+      def inject_helpers!
+        Joys::Render::Helpers.include(ActionView::Helpers)
+        Joys::Render::Helpers.module_eval do
+          def request;Thread.current[:joys_request];end
+          def params;Thread.current[:joys_params];end
+          def current_user;Thread.current[:joys_current_user];end
+          def session;Thread.current[:joys_session];end
+          def _(content);raw(content);end
+        end
+      end
+      def controller_context(controller)
+        {
+          joys_request: controller.request,
+          joys_params: controller.params,
+          joys_current_user: (controller.current_user if controller.respond_to?(:current_user)),
+          joys_session: controller.session
+        }
+      end
+      module ControllerMethods
+        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
+    class Sinatra < Base
+      def integrate!;end
+      def inject_helpers!;end
+    end
+    class Hanami < Base  
+      def integrate!;end
+      def inject_helpers!;end
+    end
+    class Roda < Base
+      def integrate!;end  
+      def inject_helpers!;end
+    end
+  end
+  class << self
+    attr_accessor :adapter,:css_registry
+    def render_joy(path,**locals)
+      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 preload!;load_helpers;load_dir(Config.layouts);load_dir(Config.components);load_css_parts;end
+    def load_helpers
+      return unless Dir.exist?(Config.helpers)
+      Dir.glob("#{Config.helpers}/**/*.rb").each do |f|
+        helper_module = Module.new
+        helper_module.module_eval(File.read(f), f)
+        Joys::Render::Helpers.include(helper_module)
+      end
+    end
+    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?|\n/, '')
+      end
+    end
+    def detect_framework!
+      @css_registry={}
+      @adapter=if defined?(ActionController::Base)&&defined?(::Rails)
+        Adapters::Rails.new
+      elsif defined?(Sinatra::Base)
+        Adapters::Sinatra.new  
+      elsif defined?(Hanami::Action)
+        Adapters::Hanami.new
+      elsif defined?(Roda)
+        Adapters::Roda.new
+      end
+      @adapter&.integrate!
+    end
+    private
+    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
+end
+Joys.detect_framework!

data/lib/joys/core.rb

@@ -4,18 +4,27 @@ 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
+    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
+  end  
   def self.reset!
-  @cache.clear
-  @templates.clear
-  @compiled_styles.clear
-  @consolidated_cache.clear
-  @layouts.clear
-  @current_component = nil
-  @current_page = nil
-end
-
+    @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
@@ -52,7 +61,8 @@ end
         old_component = @current_component
         @current_component = full_name if type == :comp
         result = cache(full_name, *args) do
-          Joys::Render.compile { instance_exec(*args, &template) }
+          # 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
@@ -85,47 +95,65 @@ end
     @current_page = old_page
     renderer.instance_variable_get(:@bf).freeze
   end
-def self.comp(name, *args, **locals, &block)
+  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)
+  # Clear any previous tracking
+  clear_tracked_components
+  
   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
+  renderer.instance_variable_set(:@bf, String.new)
+  renderer.instance_variable_set(:@current_page, "page_standalone")
+  renderer.instance_variable_set(:@used_components, Set.new)
+  renderer.instance_variable_set(:@slots, {})
   
-  comp_template = @templates["comp_#{name}"]
-  raise "No comp template defined for #{name}" unless comp_template
+  renderer.instance_eval(&block)
   
-  old_component = @current_component
-  @current_component = "comp_#{name}"
+  # Merge globally tracked components
+  tracked = get_tracked_components
+  used = renderer.instance_variable_get(:@used_components)
+  used.merge(tracked) if tracked
   
-  # Pass the block as a regular argument to the template
-  renderer.instance_exec(*args, block, &comp_template)
+  # Clear tracking after use
+  clear_tracked_components
   
-  @current_component = old_component
-  renderer.instance_variable_get(:@bf).freeze
+  renderer.instance_variable_get(:@bf)
 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}
+    def self.compile(context_name = nil, &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_variable_set(:@current_page, context_name) if context_name
       context.instance_eval(&block)
-      context.instance_variable_get(:@bf).freeze
+      
+      # CHANGE: Return a hash containing both html and the used components set
+      {
+        html: context.instance_variable_get(:@bf).freeze,
+        components: context.instance_variable_get(:@used_components)
+      }
     end
     def self.layout(&layout_block)
       template = Object.new;template.extend(Helpers);template.extend(Tags)