joys 0.1.1 → 0.1.3

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

@@ -0,0 +1,189 @@
+# 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,: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
+  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
+          # 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
+      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)
+  # Clear any previous tracking
+  clear_tracked_components
+  
+  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)
+  
+  # Merge globally tracked components
+  tracked = get_tracked_components
+  used = renderer.instance_variable_get(:@used_components)
+  used.merge(tracked) if tracked
+  
+  # Clear tracking after use
+  clear_tracked_components
+  
+  renderer.instance_variable_get(:@bf)
+end
+  module Render
+    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)
+      
+      # 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)
+      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