liquidum 1.2.0 → 1.3.0

data/config/routes.rb

@@ -1,5 +1,5 @@
 Liquidum::Engine.routes.draw do
-  resources :completions
+  resources :variables, only: :index
   resources :conversions
   resources :sandbox
   post 'render_only', to: 'sandbox#render_only'

data/lib/liquidum/configuration.rb

@@ -38,6 +38,9 @@ module Liquidum
 
     option :logger, default: -> { Logger.new($stdout).tap { |l| l.level = Logger::INFO } }, proc: true
     option :liquidum_file_system, default: "Liquidum::LiquidumFileSystem"
+    # The controller Liquidum's controllers inherit from, to decide who may
+    # use them, e.g. "Admin::BaseController". Set it in an initializer.
+    option :parent_controller, default: "::ApplicationController"
     attr_writer :i18n_store
 
     def initialize

data/lib/liquidum/drop.rb

@@ -29,12 +29,12 @@ module Liquidum
         result = send(pm)
 
         h[pm] = if result.is_a? ApplicationDrop
-                  result.to_h(max_level, current_level: current_level + 1)
-                elsif result.is_a? Enumerator::Lazy
-                  result.map { |r| r.to_h(max_level, current_level: current_level + 1) }.force
-                else
-                  result
-                end
+          result.to_h(max_level, current_level: current_level + 1)
+        elsif result.is_a? Enumerator::Lazy
+          result.map { |r| r.to_h(max_level, current_level: current_level + 1) }.force
+        else
+          result
+        end
       end
       h
     end
@@ -42,6 +42,8 @@ module Liquidum
     class << self
       def association(*associations)
         associations.each do |name|
+          self.associations << name.to_s
+
           define_method(name) do
             if @object.class.respond_to?(:reflect_on_all_associations)
               relation = @object.class.reflect_on_all_associations.find do |a|
@@ -50,7 +52,7 @@ module Liquidum
             end
             return unless relation
 
-            klass = "#{relation.class_name}Drop".classify.safe_constantize
+            klass = Drop.for_relation(relation)
 
             Rails.logger.warn "No #{klass}" and return unless klass
 
@@ -64,6 +66,81 @@ module Liquidum
           end
         end
       end
+
+      # Adds to what Liquidum works out about a variable for the editor's
+      # variable picker (see .variables):
+      #
+      #   describe :total, type: :money, hint: "Including VAT"
+      #   describe :portal_url, label: -> { I18n.t("orders.portal_url") }
+      #   describe :owner, drop: "UserDrop"
+      #   describe :tags, drop: "TagDrop", collection: true
+      #
+      # A label or hint can be a proc, to translate it in the current locale.
+      def describe(name, label: nil, type: nil, hint: nil, drop: nil, collection: nil)
+        descriptions[name.to_s] = {label: label, type: type, hint: hint, drop: drop, collection: collection}.compact
+      end
+
+      def descriptions
+        @descriptions ||= superclass.respond_to?(:descriptions) ? superclass.descriptions.dup : {}
+      end
+
+      def associations
+        @associations ||= superclass.respond_to?(:associations) ? superclass.associations.dup : []
+      end
+
+      # The model the drop is for, for labels, types and associations:
+      # OrderDrop is for Order. Override it when the names don't match.
+      def model
+        name&.delete_suffix("Drop")&.safe_constantize
+      end
+
+      # The variables a template can use on this drop, one level deep, with
+      # labels in the current locale. Only what Liquid can call is listed, so
+      # not the helpers every Liquidum::Drop has (to_gid, to_h, …).
+      def variables
+        (invokable_methods - HELPERS).sort.filter_map do |name|
+          next if instance_method(name).parameters.any? { |kind, _| kind == :req }
+
+          variable(name)
+        end
+      end
+
+      def for_relation(relation)
+        "#{relation.class_name}Drop".classify.safe_constantize
+      end
+
+      private
+
+      def variable(name)
+        description = descriptions.fetch(name, {})
+        relation = model.reflect_on_association(name) if associations.include?(name) && model.respond_to?(:reflect_on_association)
+        drop = description[:drop]&.to_s&.safe_constantize || (for_relation(relation) if relation)
+
+        Variable.new(
+          name: name,
+          label: resolve(description[:label]) || label_for(name),
+          type: (description[:type] || (drop ? :object : attribute_type(name)))&.to_s,
+          hint: resolve(description[:hint]),
+          drop: drop,
+          collection: description.fetch(:collection) { relation&.collection? || false }
+        )
+      end
+
+      def label_for(name)
+        model.respond_to?(:human_attribute_name) ? model.human_attribute_name(name) : name.humanize
+      end
+
+      def attribute_type(name)
+        return unless model.respond_to?(:attribute_types) && model.attribute_types.key?(name)
+
+        model.attribute_types[name].type
+      end
+
+      def resolve(value)
+        value.respond_to?(:call) ? value.call : value
+      end
     end
+
+    HELPERS = (public_instance_methods(false).map(&:to_s) - %w[id]) + %w[to_liquid]
   end
 end

data/lib/liquidum/liquid/tags/render_tag.rb

@@ -12,7 +12,7 @@ class RenderTag < LiquidumTag
     return unless argv1
 
     template = Liquid::Template.parse(argv1)
-    template.render(context, registers: context.registers)
+    template.render(context)
   end
 end
 

data/lib/liquidum/variable.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Liquidum
+  # A variable a template can use, as the editor's variable picker shows it.
+  # A variable with a drop has variables of its own; a collection is a list
+  # of them, to loop over.
+  Variable = Data.define(:name, :label, :type, :hint, :drop, :collection) do
+    def as_json(*)
+      {name: name, label: label, type: type, hint: hint, collection: collection, children: !drop.nil?}.compact
+    end
+  end
+end

data/lib/liquidum/variables.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Liquidum
+  # The variables available to a template, from its roots: the drops (or
+  # plain values) it's rendered with.
+  #
+  #   variables = Liquidum::Variables.new(order: OrderDrop, portal_url: :string)
+  #   variables.at("")                           # order, portal_url
+  #   variables.at("order.customer")             # the customer's variables
+  #   variables.at("order.order_lines.product")  # in a collection: an element's
+  #
+  # The editor asks for one level at a time (see Liquidum::VariablesController),
+  # so associations that lead back (order → customer → orders) are no problem.
+  # Hosts pass the roots signed, from .token, so a browser can't ask about
+  # other classes.
+  class Variables
+    attr_reader :roots
+
+    def initialize(roots)
+      @roots = roots.to_h { |name, root| [name.to_s, root] }
+    end
+
+    def at(path)
+      names = path.to_s.split(".")
+      return roots.map { |name, root| root_variable(name, root) } if names.empty?
+
+      first, *rest = names
+      variable = root_variable(first, roots[first]) if roots.key?(first)
+      rest.each { |name| variable = variable&.drop&.variables&.find { |v| v.name == name } }
+      variable&.drop&.variables
+    end
+
+    def token
+      self.class.verifier.generate(roots.transform_values { |root| root.is_a?(Class) ? {"drop" => root.name} : {"type" => root.to_s} })
+    end
+
+    class << self
+      def from_token(token)
+        roots = verifier.verified(token.to_s) or return
+
+        new(roots.transform_values { |root| root["drop"] ? root["drop"].safe_constantize : root["type"] })
+      end
+
+      def verifier
+        Rails.application.message_verifier("liquidum/variables")
+      end
+    end
+
+    private
+
+    def root_variable(name, root)
+      if root.is_a?(Class) && root < Liquid::Drop
+        model = root.model if root.respond_to?(:model)
+        label = model.respond_to?(:model_name) ? model.model_name.human : name.humanize
+        Variable.new(name: name, label: label, type: "object", hint: nil, drop: (root if root.respond_to?(:variables)), collection: false)
+      else
+        Variable.new(name: name, label: name.humanize, type: root&.to_s, hint: nil, drop: nil, collection: false)
+      end
+    end
+  end
+end

data/lib/liquidum/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Liquidum
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/liquidum.rb

@@ -9,6 +9,8 @@ require "liquidum/version"
 require "liquidum/engine"
 require "liquidum/configuration"
 require "liquidum/drop"
+require "liquidum/variable"
+require "liquidum/variables"
 
 require "liquidum/liquid/liquid_helpers"
 require "liquidum/liquid/liquid_template_extensions"
@@ -47,8 +49,13 @@ module Liquidum
       options[:registers] ||= {}
       options[:registers]["file_system"] =
         Liquidum.config.liquidum_file_system.constantize.new(options[:registers])
-      result = template.render(options[:context] || options[:assigns].stringify_keys,
-        registers: options[:registers])
+      # A Liquid::Context (from a tag) already carries its registers, and since
+      # Liquid 5.4 those are a Liquid::Registers, which render won't take again
+      result = if options[:context]
+        template.render(options[:context])
+      else
+        template.render(options[:assigns].stringify_keys, registers: options[:registers])
+      end
 
       if template.errors.present?
         Liquidum.config.logger.error "--- Template rendering errors: " + "-" * 49
@@ -63,7 +70,7 @@ module Liquidum
 
       assigns = options[:assigns].deep_stringify_keys
       assigns = assigns.merge(template.assigns.stringify_keys) if template.assigns
-      options[:registers].deep_merge!(template.registers.stringify_keys) if template.registers
+      template.registers&.each { |key, value| options[:registers][key.to_s] = value }
 
       if options[:filter].present? && Tilt[options[:filter]]
         result = Tilt[options[:filter]].new(options[:filter_options]) do

data/liquidum.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency("i18n", ["~> 1.8"])
   spec.add_runtime_dependency("kramdown", ["~> 2.1"])
   spec.add_runtime_dependency("kramdown-parser-gfm", ["~> 1.0"])
-  spec.add_runtime_dependency("liquid", ["< 5.4"])
+  spec.add_runtime_dependency("liquid", ["< 6"])
   spec.add_runtime_dependency("parslet", [">= 0"])
   spec.add_runtime_dependency("pg", [">= 0"])
   spec.add_runtime_dependency("rails", [">= 5.2"])

data/mise.toml

@@ -0,0 +1,4 @@
+# If gpg fails use `MISE_GPG_VERIFY=false`
+[tools]
+node = "24"
+ruby = "4"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: liquidum
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Tom de Grunt
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -86,14 +85,14 @@ dependencies:
     requirements:
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -269,26 +268,36 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".devcontainer/devcontainer-lock.json"
+- ".devcontainer/devcontainer.json"
+- ".devcontainer/docker-compose.yml"
+- ".devcontainer/env.conf"
+- ".devcontainer/postStart.sh"
 - ".github/workflows/gem-push.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- ".shipkit.yml"
+- ".worktreeinclude"
+- CHANGELOG.md
 - Gemfile
 - MIT-LICENSE
 - README.md
 - Rakefile
 - TODO.md
 - app/controllers/liquidum/application_controller.rb
-- app/controllers/liquidum/completions_controller.rb
 - app/controllers/liquidum/conversions_controller.rb
 - app/controllers/liquidum/sandbox_controller.rb
+- app/controllers/liquidum/variables_controller.rb
 - app/helpers/liquidum/application_helper.rb
 - app/jobs/liquidum/application_job.rb
 - app/models/concerns/liquidum/to_liquid.rb
 - app/models/liquidum/sandbox.rb
+- app/tables/liquidum/application_table.rb
 - app/tables/liquidum/sandboxes_table.rb
 - app/views/liquidum/conversions/index.html.slim
 - app/views/liquidum/sandbox/edit.html.slim
 - app/views/liquidum/sandbox/index.html.slim
+- bin/de
 - bin/rails
 - bin/rubocop
 - config/routes.rb
@@ -321,13 +330,15 @@ files:
 - lib/liquidum/liquid/parser.rb
 - lib/liquidum/liquid/tags/helper_tag.rb
 - lib/liquidum/liquid/tags/render_tag.rb
+- lib/liquidum/variable.rb
+- lib/liquidum/variables.rb
 - lib/liquidum/version.rb
 - liquidum.gemspec
+- mise.toml
 homepage: https://github.com/entdec/liquidum
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -342,8 +353,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Liquid templating - on steroids
 test_files: []

data/app/controllers/liquidum/completions_controller.rb

@@ -1,15 +0,0 @@
-require_dependency "liquidum/application_controller"
-
-module Liquidum
-  class CompletionsController < ApplicationController
-    def index
-      q          = params[:q]
-      klass      = q.classify.safe_constantize
-      drop       = q.classify.concat('Drop').safe_constantize
-      invokables = drop&.invokable_methods || []
-      # drop_relations = klass.reflect_on_all_associations.map(&:name).select {|n| invokables.include?(n.to_s) }
-
-      render json: { q: q, completions: invokables }
-    end
-  end
-end