rsx-rb 0.1.0

data/lib/rsx/safe_string.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RSX
+  # An HTML-safe string. Anything wrapped in a SafeString is emitted verbatim;
+  # everything else that flows into a template is escaped.
+  #
+  # SafeString subclasses String so it interoperates with ActionView output
+  # buffers, ActiveSupport::SafeBuffer and plain Ruby string operations without
+  # requiring ActiveSupport to be loaded.
+  class SafeString < String
+    def html_safe?
+      true
+    end
+
+    # Rails calls this when concatenating into an output buffer.
+    def to_s
+      self
+    end
+
+    def to_safe_string
+      self
+    end
+
+    # Concatenation keeps the safety contract: unsafe operands are escaped.
+    def +(other)
+      SafeString.new(super(RSX.child(other)))
+    end
+
+    def <<(other)
+      super(RSX.child(other))
+    end
+    alias concat <<
+
+    def *(times)
+      SafeString.new(super)
+    end
+
+    def inspect
+      "#<RSX::SafeString #{super}>"
+    end
+  end
+end

data/lib/rsx/tasks.rake

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+namespace :rsx do
+  desc "Compile every .rsx file and warm the on-disk compile cache"
+  task precompile: :environment do
+    files = RSX.loader.files
+    RSX.precompile!
+    puts "rsx: precompiled #{files.length} file(s) into #{RSX.config.cache_dir || "memory"}"
+  end
+
+  desc "Delete compiled .rsx output and clear the render cache"
+  task clear: :environment do
+    RSX.config.compile_cache.clear
+    RSX.cache.clear
+    puts "rsx: cleared #{RSX.config.cache_dir || "memory"}"
+  end
+
+  desc "Load every .rsx file and report the components it defines"
+  task components: :environment do
+    RSX.load_all
+    RSX.loader.entries.sort_by(&:path).each do |entry|
+      names = entry.components.map { |component| component.name || "(anonymous)" }
+      puts format("%-60s %s", entry.path.sub("#{Dir.pwd}/", ""), names.join(", "))
+    end
+  end
+end

data/lib/rsx/template.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RSX
+  # A .rsx file rendered as markup rather than as a named component.
+  #
+  # The file body becomes a method on an anonymous Component subclass, so a
+  # template gets the whole component toolkit (children, caching, context,
+  # helpers) and is compiled once no matter how often it is rendered.
+  class Template
+    attr_reader :path, :digest
+
+    def self.load(path)
+      absolute = File.expand_path(path)
+      raise FileNotFoundError, "no such RSX file: #{absolute}" unless File.file?(absolute)
+
+      new(File.read(absolute), path: absolute)
+    end
+
+    def self.from_ruby(ruby, path: nil, digest: nil)
+      allocate.tap { |template| template.send(:build, ruby, path, digest) }
+    end
+
+    def initialize(source, path: nil)
+      digest = RSX.config.compile_cache.digest(source.to_s)
+      ruby = RSX.config.compile_cache.fetch(path || "template", source.to_s) do
+        Transformer.transform(source.to_s, path: path)
+      end
+      build(ruby, path, digest)
+    end
+
+    def render(props = nil, context: nil)
+      value = @component.new(props, context).rsx_render(props)
+
+      # A file whose last statement is a component definition (or an
+      # `export default`) renders that component with the props it was given.
+      if value.is_a?(Class) && value < Component
+        RSX.safe(value.rsx_call(props, context))
+      else
+        RSX.safe(RSX.child(value))
+      end
+    end
+
+    def component
+      @component
+    end
+
+    private
+
+    def build(ruby, path, digest)
+      @path = path
+      @digest = digest
+      @component = Class.new(Component)
+      @component.rsx_source_path = path
+      @component.rsx_source_digest = digest
+
+      body = ruby.end_with?("\n") ? ruby : "#{ruby}\n"
+      # Evaluating from line 0 puts the generated `def` above line 1, so every
+      # line of the template keeps its original number in backtraces.
+      @component.class_eval("def rsx_render(props = nil)\n#{body}end\n", path || "(rsx)", 0)
+      self
+    end
+  end
+end

data/lib/rsx/template_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RSX
+  # ActionView handler for .rsx templates: app/views/users/show.html.rsx
+  #
+  # The handler returns Ruby source, which ActionView compiles into a method on
+  # the view context. That means a .rsx view is compiled once per process and
+  # every Rails helper (url helpers, `t`, form builders, CSRF tags) is available
+  # directly, because `self` inside the template is the view.
+  class TemplateHandler
+    class << self
+      # ActionView passes (template) on older versions and (template, source)
+      # on 6.0+.
+      def call(template, source = nil)
+        source ||= template.source
+        identifier = template.respond_to?(:identifier) ? template.identifier : nil
+        compile(source, identifier)
+      end
+
+      def compile(source, identifier = nil)
+        ruby = RSX.compile(source, path: identifier)
+
+        # Everything is kept on one line up to the body so that line numbers in
+        # the compiled method still match the .rsx file.
+        +"__rsx_value = begin;" << ruby << "\nend\n::RSX.template_result(__rsx_value)\n"
+      end
+
+      # Templates render markup, not a component, so there is nothing to escape
+      # on the way out.
+      def handles_encoding?
+        true
+      end
+    end
+  end
+end